L'agence nationale de la sécurité des SI sort enfin du bois ! Ses recommandations en matière de GenAI étaient attendues. Pas de surprise, mais un ensemble pertinent, à garder en tête.
En tant qu'architecte SI, notre tâche principale est de concevoir des systèmes complexes qui répondent aux exigences du client. Cependant, nous pouvons parfois être tentés de concevoir des systèmes trop complexes qui vont au-delà de ce qui est nécessaire. Avant de commencer à concevoir, nous devrions prendre en compte certains principes clés de l'architecture logicielle qui peuvent être appliqués à chaque conception. Ces principes comprennent la séparation des préoccupations (SoC) et les principes SOLID. Dans cet article, nous allons discuter de ces deux principes en détail.
SoC - Separation Of Concerns
L'un des principes de conception les plus importants en matière d'architecture logicielle est la séparation des responsabilités (SoC, Separation of Concerns). Ce principe préconise la décomposition d'un système complexe en parties distinctes, indépendantes et gérables, chacune étant responsable d'un aspect ou d'une fonction spécifique du système. Il est nécessaire de séparer les responsabilités lors du développement d'un logiciel complexe pour garantir son évolutilivité et sa maintenabilité, et la SoC nous aide à y parvenir.
L'idée principale derrière SoC est de minimiser la complexité d'un système en le divisant en parties plus petites qui peuvent être développées, testées et maintenues indépendamment, sans interférer avec les autres parties. En séparant les responsabilités, les développeurs peuvent se concentrer sur le développement de chaque partie du système avec une compréhension claire de son objectif et des interactions qu'elle a avec les autres parties.
Pour mettre en œuvre les SoC, nous pouvons utiliser des couches, des modules ou des services, chaque couche ou module étant responsable d'une fonction spécifique. Par exemple, le stockage des données, l'interface utilisateur, la logique business ou la communication avec des systèmes externes. Cette approche permet aux développeurs de se concentrer sur leur domaine d'expertise, ce qui facilite l'écriture, le test et la maintenance des logiciels. Elle permet également d'ajouter plus facilement de nouvelles fonctionnalités au système sans perturber le code existant.
Principes SOLID
La norme SOLID est un autre ensemble de principes clés qui devraient être utilisés dans presque tous les projets logiciels. SOLID signifie :
Single Responsibility Principle (principe de responsabilité unique),
Open-Closed Principle (principe d'ouverture et de fermeture),
Liskov Substitution Principle (principe de substitution de Liskov),
Interface Segregation Principle (principe de séparation des interfaces),
Dependency Inversion Principle (principe d'inversion des dépendances).
Chacun de ces principes est essentiel à la conception et à l'architecture d'un système logiciel.
Le principe de responsabilité unique (SRP) stipule que chaque classe ou module ne doit avoir qu'une seule responsabilité, ce qui facilite la compréhension et la modification. Le principe d'ouverture et de fermeture (OCP) suggère que les classes doivent être ouvertes à l'extension mais fermées à la modification, ce qui signifie qu'il doit être facile d'ajouter de nouvelles fonctionnalités sans modifier le code existant.
Le principe de substitution de Liskov (LSP) stipule que tout objet d'une superclasse doit pouvoir être remplacé par un objet d'une sous-classe sans affecter la correction du programme. Le principe de ségrégation des interfaces (ISP) stipule qu'aucun client ne doit être contraint de dépendre de méthodes qu'il n'utilise pas, et le principe d'inversion des dépendances (DIP) stipule que les modules de haut niveau ne doivent pas dépendre des modules de bas niveau, mais que les deux doivent dépendre d'abstractions.
Deux principes à garder en tête et appliquer
Nous avons abordé deux principes clés de la conception d'une architecture logicielle : la séparation des préoccupations (SoC) et les principes SOLID. Ces deux principes permettent de minimiser la complexité d'un système en le divisant en parties plus petites et plus faciles à gérer, chaque partie étant responsable d'un aspect ou d'une fonction spécifique du système. Ces principes facilitent le développement, le test et la maintenance des logiciels, ainsi que l'ajout de nouvelles fonctionnalités au système sans perturber le code existant.
En tant qu'architecte logiciel, garder ces principes à l'esprit nous aidera à concevoir des systèmes logiciels efficaces et performants qui répondent aux besoins de nos clients.
