L'analyse des exigences logicielles résout le problème de « quoi faire », tandis que le processus de conception de logiciels résout le problème de « comment le faire »

La conception logicielle est le processus de transformation des exigences logicielles en représentation logicielle. Elle se compose principalement de deux étapes : l'étape de conception de l'architecture logicielle et la conception au niveau des composants.

À l'aide d'une approche de conception, les informations sur les exigences logicielles représentées par les modèles de données, fonctionnels et comportementaux dans le modèle d'analyse logicielle sont transmises à la phase de conception, ce qui aboutit à la conception de données/classes, à la conception d'architecture, à la conception d'interfaces et à la conception au niveau des composants.

Conception de données/classes : transformez le modèle de classe d'analyse en implémentation de classe et en structures de données requises pour l'implémentation logicielle

Conception architecturale : la conception architecturale définit la structure globale du logiciel

Conception d'interface : la conception d'interface décrit comment communiquer au sein du logiciel, entre le logiciel et les systèmes collaboratifs, et entre les collègues logiciels.

Conception au niveau des composants : la conception au niveau des composants transforme les éléments structurels de l'architecture logicielle en une description procédurale des composants logiciels.

Dans le processus de conception de logiciels, nous devons prêter une attention particulière aux facteurs de qualité du logiciel.

Les objectifs du processus de conception de logiciels McGlanghlin sont :

1) La structure conçue doit être une structure hiérarchique pour établir le contrôle entre les composants logiciels.

2) La conception doit être modulaire, divisant logiquement le logiciel en composants qui remplissent des fonctions ou sous-fonctions spécifiques.

3) La conception doit inclure à la fois l'abstraction des données et l'abstraction des processus.

4) La conception doit établir des modules dotés de caractéristiques fonctionnelles indépendantes.

5) La conception doit établir des interfaces qui réduisent les connexions complexes entre le module et l'environnement externe.

6) La conception doit être capable d'établir une méthode pilotable et reproductible basée sur les informations obtenues à partir de l'analyse des exigences logicielles.

1) Élaborer un cahier des charges

2) Architecture et conception d'interface

3) Conception de données/classes

4) Conception au niveau des composants (processus)

5) Rédiger les documents de conception

6) Revue de conception

L'abstraction est une stratégie de base pour contrôler la complexité à mesure que l'échelle de conception de logiciels augmente progressivement.

Rechercher progressivement le raffinement

La modularisation, c'est-à-dire la division d'un logiciel en composants plus petits, indépendants mais interdépendants selon des principes prescrits, est en réalité un processus de décomposition et d'abstraction du système.

Un module est une collection d'objets de programme tels que des descriptions de données et des instructions exécutables. Il est nommé individuellement et est accessible par son nom.

Par exemple, processus. Fonctions, sous-programmes, macros, etc.

Les détails d'implémentation de chaque module doivent être masqués des autres modules

Les informations (y compris les données et les procédures) contenues dans le bloc ne peuvent pas être utilisées par d'autres modules qui n'ont pas besoin de ces informations.

Grâce au masquage des informations, des restrictions d'accès aux détails du processus et aux structures de données locales du module peuvent être définies et appliquées.

Indépendance fonctionnelle : l'indépendance fonctionnelle est le résultat direct de concepts tels que la modularité, l'abstraction, la dissimulation d'informations et la localisation. L'indépendance fonctionnelle peut être obtenue en développant des modules fonctionnellement spécifiques et en évitant les interactions excessives avec d'autres modules.

L’importance de l’indépendance fonctionnelle

L'indépendance fonctionnelle peut être mesurée par deux indicateurs : la cohésion et le couplage

① Faciliter la communication entre les parties prenantes

②Facile à une prise de décision précoce dans la conception du système

③Abstraction transmissible au niveau du système

Architecture logicielle commune

La grande majorité peut être classée parmi un nombre relativement restreint de styles architecturaux.

Chaque style décrit une catégorie de système, qui comprend :

Certaines données (comme un fichier ou une base de données) sont stockées au centre de la structure et sont fréquemment utilisées, ajoutées, supprimées ou modifiées par d'autres composants.

Cette structure convient aux données d'entrée devant être transformées en données de sortie par une série de composants de calcul ou de traitement.

Ce style permet à un concepteur de logiciels de concevoir une architecture très facile à modifier et à étendre.

Contient : une architecture de style programme/sous-programme principal et une architecture de style appel de procédure à distance

Il y a quelques concepts à comprendre ici :

Méthodes permettant aux composants du système d'encapsuler des données et de manipuler des données

L'interaction et la coordination entre les composants sont transmises via des messages

Dans cette structure, différents niveaux sont définis et chaque niveau effectue des opérations plus proches des instructions machine que le niveau externe.

Pour la même exigence logicielle, différentes structures logicielles seront dérivées en raison des différents principes des différentes méthodes de conception.

Différentes structures logicielles pour un même problème

1) Définir des scénarios d'application (scénarios) : exprimer le système du point de vue de l'utilisateur à travers des diagrammes de cas d'utilisation

2) Dériver les exigences, les contraintes et la description de l'environnement : cela fait partie de l'ingénierie des exigences pour garantir que toutes les préoccupations des clients sont répertoriées.

3) Décrire le style architectural capable de gérer les situations et les exigences ci-dessus

4) Évaluer chaque performance du système individuellement. Les performances pour la conception d'architecture comprennent : la fiabilité, les performances, la sécurité, la maintenabilité, la flexibilité, la testabilité, la portabilité, la réutilisabilité et l'interopérabilité, etc.

5) Pour différentes formes architecturales, évaluer la sensibilité de ces performances mentionnées à l'étape 4. Cela peut être évalué de cette manière : apporter quelques petites modifications à l'ensemble de l'architecture, analyser et déterminer s'il y a des changements sensibles dans les performances d'appel. Les performances fortement affectées par les modifications architecturales sont appelées points sensibles.

6) Évaluez les architectures proposées à l'étape 3 à travers l'analyse de sensibilité à l'étape 5. La méthode décrite par SEI est la suivante : Lorsque les points sensibles d'une architecture sont déterminés, nous devons trouver les facteurs qui nécessitent le plus de points de compromis dans le système (points de compromis). Le facteur de compromis signifie que la modification de ce contenu dans l'architecture entraînera des changements sensibles dans les performances du système. Par exemple, les performances d'un système avec une structure client-serveur sont étroitement liées au nombre de serveurs dans le système (par exemple, augmenter le nombre de serveurs améliorera les performances du système dans une certaine mesure)... Dans dans ce cas, le nombre de serveurs est ce point d'équilibre dans l'architecture.

(1) Améliorer la structure du logiciel et améliorer l'indépendance des modules

(2) Profondeur, largeur, sortance et entrée appropriées du module

(3) La portée de jugement du module doit être dans sa portée de contrôle

(4) S'efforcer de réduire la complexité des interfaces des modules

(5) Concevoir un module avec une seule entrée et une seule sortie

(6) La fonctionnalité du module doit être prévisible et la taille du module doit être modérée.

(7) Généralement, il est préférable qu'un module contienne environ 30 à 50 instructions.

(8) Une structure logicielle bien conçue présente généralement une diffusion plus élevée au niveau de la couche supérieure, une diffusion moindre au niveau de la couche intermédiaire et une diffusion élevée au niveau de la couche inférieure.

Déterminer l'algorithme utilisé pour chaque composant, sélectionner un outil approprié pour exprimer le processus algorithmique et rédiger une description procédurale détaillée du composant.

Déterminer les structures de données utilisées en interne par chaque composant

À la fin de la conception au niveau des composants, les résultats ci-dessus doivent être écrits dans la spécification de conception au niveau des composants et transformés en un document formel par examen, qui servira de base pour l'étape suivante (étape de codage).

Une définition plus populaire est : « Si les blocs de code d'un programme sont connectés uniquement via les trois structures de contrôle de base que sont la séquence, la sélection et la boucle, et que chaque bloc de code n'a qu'une seule entrée et une seule sortie, alors le programme est dit structuré. . de"

Avec le développement de nouvelles méthodes et technologies de développement de logiciels telles que l'orientation objet et la réutilisation de logiciels, une approche de développement plus réaliste et plus efficace peut être une combinaison organique de méthodes descendantes et ascendantes.

Organigramme du programme

Diagramme NS

TAMPON

Lorsque l'algorithme contient plusieurs sélections de conditions imbriquées, il est difficile de le décrire clairement à l'aide d'organigrammes de programme, de diagrammes N-S ou de PAD.

Cependant, les tableaux de décision peuvent exprimer clairement la correspondance entre des combinaisons complexes de conditions et les actions à entreprendre.

L'avantage de la table de décision est qu'elle peut décrire toutes les règles de traitement de manière concise et sans ambiguïté.

Cependant, la table de décision représente la logique statique, qui est le résultat possible sous une certaine combinaison de valeurs de condition. Elle ne peut pas exprimer la séquence de traitement, ni la structure de la boucle.

PDL (Program Design Language) est un langage utilisé pour décrire la conception de l'algorithme et les détails de traitement des composants fonctionnels, appelé langage de conception.

C'est une sorte de pseudo-code. D'une manière générale, les règles de grammaire du pseudocode sont divisées en « grammaire externe » et « grammaire interne »

Exemples d'utilisation du PDL

Fonctionnalités PDL

Le but ultime de la conception de logiciels est d'obtenir la meilleure solution

« Meilleure » signifie que parmi toutes les solutions candidates, la solution capable d'atteindre une productivité, une fiabilité et une maintenabilité plus élevées est sélectionnée en fonction des conditions d'économie des coûts de développement, de réduction de la consommation de ressources et de raccourcissement du temps de développement.

Contenu de la revue de conception

Il existe deux types d’examen : l’examen formel et l’examen informel.