Concept: Elever le niveau d'abstraction
Ce principe décrit la manière de réduire la complexité en élevant le niveau d'abstraction.
Description principale

Introduction

La complexité est un point clé du développement logiciel. L'élévation du niveau d'abstraction permet de réduire la complexité ainsi que la quantité de documentation requise pour le projet. La réutilisation de ressources existantes, l'utilisation d'outils de modélisation de haut niveau et la stabilisation précoce de l'architecture peuvent permettre d'atteindre cet objectif.

          
Avantages
  • Productivité
  • Complexité réduite.
Pattern
  1. Réutiliser des actifs existants
  2. Utiliser des outils et des langages de haut niveau afin de réduire la quantité de documentation produite
  3. Se concentrer en priorité sur l'architecture
  4. Architecturer la résilience, la qualité, la capacité de compréhension et le contrôle de complexité.
Anti-Patterns
  • Commencer à partir d'exigences de haut niveau vagues pour développer un code personnalisé :
    • Dans la mesure où peu d'abstractions sont utilisées, de nombreuses discussions ont lieu au niveau du code plutôt qu'au niveau conceptuel, ce qui, entre autres choses, limite les possibilités de réutilisation.
    • Les exigences enregistrées de manière informelle et d'autres informations nécessitent que les décisions et les spécifications soient réexaminées à plusieurs reprises
    • Un manque d'importance accordé à l'architecture se traduira par des remaniements majeurs à la fin du projet.

Discussion 

La complexité constitue l'un des problèmes majeurs du développement logiciel. Il est clair que la réduction de la complexité a un impact considérable sur la productivité. Le fait de travailler à un niveau d'abstraction plus élevé réduit la complexité et facilite la communication.

Une approche efficace en matière de réduction de la complexité est la réutilisation des actifs existants, comme les composants réutilisables, les systèmes en vigueur, les processus métier existants, les patterns ou les logiciels libres. Les deux exemples suivants de réutilisation des actifs existants ont eu un impact majeur dans l'industrie logicielle :

  • la réutilisation de middleware, comme les bases de données, les serveurs web et les portails, et, plus récemment,
  • les logiciels libres qui offrent des composants dont on peut tirer profit.

De plus, les services Web auront probablement un impact majeur sur la réutilisation des ressources existantes, dans la mesure où ils fournissent des moyens simples de réutiliser des fragments essentiels d'une fonctionnalité sur des plateformes disparates et d'offrir un couplage souple entre le consommateur et le fournisseur d'un service. Cela signifie qu'il est plus facile de tirer profit de différentes combinaisons de services afin de satisfaire les besoins métier. La réutilisation est également facilitée par le recours à des standards ouverts tels que RAS, UDDI, SOAP, WSDL, XML et UML.

Diagramme illustrant la réutilisation d'actifs existants via des architectures orientées service
Réutilisation d'actifs existants via des architectures orientées service.
Un des problèmes majeurs de la réutilisation est que les deux composants doivent connaître l'existence de chacun au moment du développement. Les architectures orientées service minimisent ce problème en fournissant ce qui est appelé un couplage souple : un consommateur de services peut trouver un fournisseur de services de manière dynamique. Ainsi, il est possible d'intégrer des composants existants ou des systèmes en vigueur dans des services, afin de permettre à d'autres composants ou applications d'accéder dynamiquement à leurs fonctionnalités via une interface basée sur des standards, indépendante de la plateforme ou de la technologie d'implémentation.

Une autre approche permettant de réduire la complexité et d'améliorer la communication consiste à tirer profit d'outils, d'infrastructures préfabriquées et de langages de haut niveau :

  • Les langages standard tels que le langage UML (Unified Modeling Language) et les langages d'application rapide comme EGL permettent d'exprimer des éléments de haut niveau, comme les processus métier et les composants de service, ce qui facilite la collaboration autour de ces éléments tout en masquant les détails inutiles.
  • Les outils de conception et de construction peuvent automatiser le passage d'éléments de haut niveau à un code :
    • Ils fournissent des assistants qui automatisent les tâches de conception, de construction et de test en générant du code et en permettant l'utilisation de fragments de code,
    • Ils convertissent l'intégration et le test en des tâches de développement continues via des environnements de test, de construction et de développement intégrées.
  • Les outils de gestion de portefeuille qui permettent la gestion de l'aspect financier et d'autres aspects de projets multiples en une seule entité plutôt qu'en un ensemble d'entités séparées.

En résumé, les outils de haut niveau capturent graphiquement les informations de modélisation clés, ce qui constitue un moyen puissant et attractif de synthétiser et de présenter ces informations. Les avantages de la modélisation visuelle sont traités de manière plus détaillée dans Matériel de support : modélisation visuelle.

Une troisième approche de la gestion de la complexité consiste à se concentrer sur l'architecture, afin de définir une activité ou pour développer un système ou une application. Dans le développement logiciel, l'objectif est de concevoir, implémenter et tester l'architecture tôt dans le projet. Ce la signifie qu'il est nécessaire de se concentrer sur les objectifs suivants le plus tôt possible dans le projet :

  • Définir des blocs de construction de haut niveau et les composants les plus importants, leurs responsabilités et leurs interfaces.
  • Concevoir et implémenter des mécanismes architecturaux, c'est-à-dire, des solutions clés en main pour des problèmes communs, comme par exemple la manière de traiter la persistance ou la récupération de place.

La mise en place d'une architecture précoce permet d'obtenir squelette du système, ce qui rend plus facile la gestion de la complexité au fur et à mesure de l'évolution du projet en termes de ressources humaines, de composants, de fonctionnalités et de code. Il est également possible d'identifier les actifs réutilisables et les aspects du système nécessitant une construction personnalisée.