Introduction au Génie Logiciel
1. Introduction
Programmer n'est pas concevoir un système informatique.
La technique est nécessaire, mais pas aussi importante qu'on pourrait le croire.
Le vrai problème difficile réside dans l'organisation et la gestion.
- Difficulté de formalisation
- Multitude de paramètres et de facteurs
- Gestion des ressources (financières, humaines, matérielles, temporelles)
2. Comment acquérir ou développer un système sur mesure ?
Que le logiciel soit développé en interne ou acheté et sous-traité, il est essentiel de savoir comment acquérir ou développer un système sur mesure.
Comment avoir ou donner confiance dans le respect des coûts, du calendrier et des besoins fonctionnels ?
3. Définitions
Le génie logiciel (software engineering) est une science du génie industriel qui étudie les méthodes de travail et les bonnes pratiques des ingénieurs développant des logiciels.
Il se concentre particulièrement sur les procédures systématiques permettant d'obtenir des logiciels de grande taille, correspondant aux attentes des clients, fiables, à coût d'entretien réduit et performants, tout en respectant les délais et les coûts de construction.
Il s'agit d'un ensemble de moyens (techniques et méthodes) mis en œuvre pour la construction de systèmes informatiques et de logiciels.
4. Genèse et Objectifs
4.1. Difficultés de maîtrise
- Maîtrise des coûts
- Réalisation de plannings
- Maîtrise des délais
- Amélioration de la productivité et de la qualité des logiciels
4.2. Difficultés liées aux projets de grande ampleur
- Gestion de projets logiciels complexes (Programming in the Large)
- Nombreux échecs dus à des résultats insatisfaisants pour les clients finaux
Ces défis surviennent dans un contexte de compétition internationale sévère.
5. Difficultés liées à la nature du logiciel
- Un logiciel ne s'use pas : sa fiabilité dépend uniquement de sa conception.
- Pour rester utilisé, un logiciel doit évoluer.
- Absence de direction clairement exprimée.
- Changements fréquents et contradictions des besoins.
6. Difficultés liées aux personnes
- Les utilisateurs ne savent pas toujours ce qu'ils veulent ou ne savent pas bien l'exprimer.
- Communication difficile entre personnes de métiers différents (jargons).
- Les informaticiens sont souvent perçus comme introvertis et peu solidaires du groupe.
- Nombreux autodidactes qui croient détenir des compétences.
7. Difficultés technologiques
- Courte durée de vie des matériels.
- Multiplicité des méthodes et langages de programmation.
- Évolution constante des outils de développement.
- Nécessité d'adaptation, de formation et d'investissements lourds.
8. Répartition des coûts de développement (référence Boehm)
Les coûts de développement varient selon les types de logiciels.
-
Analyse/Conception :
- 33-34 % pour les systèmes d'exploitation et l'aérospatiale.
- 44-46 % pour le contrôle industriel, le calcul scientifique et la gestion.
-
Codage :
- 17-20 % pour les systèmes d'exploitation, le contrôle industriel et l'aérospatiale.
- 26-28 % pour le calcul scientifique et la gestion.
-
Test/Intégration :
- 28-34 % pour le contrôle industriel, le calcul scientifique et la gestion.
- 46-50 % pour les systèmes d'exploitation et l'aérospatiale.
-
Maintenance :
- Coûts très importants.
- Peu de capitaux d'investissement nécessaires.
- Frais de personnel élevés.
9. Quelques thèmes abordés par le Génie Logiciel
- Qualification du personnel par la formation.
- Procédures de gestion de la qualité logicielle.
- Outils dédiés au Génie Logiciel.
- Langages et environnements de programmation.
- Prototypage.
Il n'existe pas de remède miracle, mais certaines voies peuvent être explorées :
- Méthodes formelles et semi-formelles.
- Réutilisabilité.
- L'approche objet.
Les Cycles de Vie du Développement Logiciel
1. Définition d'un cycle de vie logiciel
Un cycle de vie logiciel est une succession d'activités de développement.
Il inclut :
- La définition des pré et post-conditions pour chaque phase.
- Les procédures de gestion et d'encadrement.
- Les procédures de mesure.
Le cycle de vie logiciel est synonyme de méthodologie logicielle.
2. Étapes d'un cycle de vie
- Analyse : opportunité fonctionnelle et faisabilité technique.
- Conception : choix tactiques de réalisation et d'architecture.
- Codage : réalisation informatique des opérations.
- Test : tests unitaires et d'intégration.
- Exploitation et maintenance.
3. Les deux grandes catégories de cycles de vie
- Les cycles linéaires : succession d'étapes ordonnées.
- Les cycles itératifs : développement incrémental par évolutions.
4. Limites du modèle linéaire
Les projets logiciels comportent souvent une part d'inconnu et donc de risques.
- Méconnaissance des besoins par le client.
- Incompréhension des besoins par le fournisseur.
- Instabilité des besoins.
- Choix technologiques.
- Mouvements de personnel.
Le processus de développement logiciel n'est pas naturellement linéaire.
5. Les cycles de vie itératifs
Ces cycles permettent d'évaluer des éléments concrets au cours du développement.
- Élimination de l'effet tunnel.
- Basés sur l'évolution de prototypes exécutables et mesurables.
- Diminution de l'importance des documents de spécification détaillée.
- Livraisons intermédiaires pour des résultats concrets réguliers.
- Meilleure anticipation et gestion des problèmes.
- Meilleure prise en compte des modifications de spécification.
- Intégration progressive des composants.
6. Le cycle en spirale (Boehm)
À chaque itération (spire), le logiciel doit passer par une analyse, une conception, un codage et des tests complets.
Chaque itération doit aboutir à un état quasi commercialisable.
- Grand intérêt pour le prototypage incrémental.
- Très utilisé dans les projets basés sur l'approche objet.
- La première spire doit inclure les éléments les plus abstraits et le cœur fonctionnel minimum du système.
Principe : "Design a little, code a little".
Facteurs de Qualité Logicielle
1. Facteurs externes (visibles par le client)
- Validité : aptitude du produit logiciel à remplir ses fonctions selon le cahier des charges.
- Exactitude : le logiciel fournit les bons résultats.
- Robustesse : le logiciel réagit correctement aux données erronées.
- Fiabilité : exactitude + robustesse.
- Stabilité : possibilité d'intégrer des modifications légères de spécification.
- Efficacité : optimisation des ressources matérielles (performances, encombrement mémoire).
- Facilité d'emploi : apprentissage, utilisation, préparation des données, interprétation des erreurs.
- Compatibilité : facilité à combiner le logiciel avec d'autres logiciels.
2. Facteurs internes
- Vérifiabilité : facilité de préparation des procédures de test.
- Maintenabilité : support dans le temps, testabilité, traçabilité.
- Portabilité : facilité de transfert sous différents environnements.
- Intégrité : protection du code et des données contre les accès non autorisés.
- Cohésion : forte cohésion dans les modules.
- Faible couplage entre les modules.
Des Méthodes Fonctionnelles aux Méthodes Objet
1. L'approche fonctionnelle
Cette méthode repose sur un raisonnement en termes de fonctions du système.
- L'accent est mis sur les fonctions plutôt que sur les données.
- Séparation des données et du code de traitement.
- Transposition des contraintes matérielles dans les méthodes.
- Diffusion des responsabilités.
- Intégrité des données non garantie.
- Ajout possible de nouvelles opérations à tout moment.
- Décomposition fonctionnelle descendante.
2. L'approche objet
- Regroupement des données et traitements.
- Réduction de l'écart entre le monde réel et sa représentation informatique.
- Localisation des responsabilités grâce à l'encapsulation.
- Décomposition par identification des relations entre objets (association, composition, généralisation/spécialisation).
Évolution des Méthodes et Panorama des Méthodologies
1. Méthodes structurées
- Programmation structurée (Dijkstra).
- Décomposition fonctionnelle descendante (SA/SD).
- SADT/SART.
2. Modélisation de systèmes d'information
- Diagrammes entités-relations.
- Méthode MERISE.
3. Méthodes objet
- OOD : Booch (1991, 1993).
- OOA : Coad-Yourdon (1990).
- HOOD : pour Ada (1988).
- OOM : Bouzeghoub (1993).
- OOSE : Jacobson.
- OMT : Rumbaugh (1991, 1993).
La Spécification UML
1. Présentation d'UML
UML (Unified Modeling Language) est un langage graphique standardisé pour modéliser tous les types de systèmes informatiques.
- Comprendre et décrire les besoins.
- Concevoir et construire des solutions.
- Documenter un système tout au long du cycle de développement.
- Communiquer entre les membres de l'équipe.
UML offre une liberté de conception tout en fournissant une notation unifiée.
2. Historique d'UML
- UML 0.9 (1996).
- UML 1.0 (1997).
- UML 1.1 (1997).
- UML 1.2 (1997).
- UML 2.3 (2010).
- Dernière spécification révisée par l'OMG en 2010.
3. Les diagrammes d'UML
UML propose 9 types de diagrammes répartis en quatre catégories :
- Structurels (statiques) : classes, objets, composants, déploiement, paquetages, structures composites.
- Comportementaux (dynamiques) : cas d'utilisation, activités, états-transitions.
- Interaction : séquence, communication, synthèse des interactions, timing.
- Implémentation : composants, déploiement.
4. Classification des diagrammes
Les diagrammes d'UML peuvent être répartis selon trois axes :
- Fonctionnels : diagramme de cas d'utilisation.
- Statiques : diagramme de classes, diagramme d'objets, diagramme de composants, diagramme de déploiement, diagramme des paquetages, diagramme des structures composites.
- Dynamiques : diagramme de séquence, diagramme de collaboration, diagramme d'états, diagramme d'activités.
FAQ sur le Génie Logiciel
1. Qu'est-ce que le génie logiciel et pourquoi est-il important ?
Le génie logiciel est une discipline qui applique des méthodes et techniques systématiques pour développer des logiciels fiables, de haute qualité et adaptés aux besoins des clients. Il est crucial pour maîtriser les coûts, les délais et la complexité des projets logiciels.
2. Quels sont les principaux facteurs de qualité logicielle ?
Les principaux facteurs incluent la validité, l'exactitude, la robustesse, la fiabilité, la stabilité, l'efficacité, la facilité d'emploi, la compatibilité, la vérifiabilité, la maintenabilité, la portabilité et l'intégrité.
3. En quoi consiste le cycle en spirale dans le développement logiciel ?
Le cycle en spirale est une méthodologie itérative qui combine analyse, conception, codage et tests à chaque itération. Chaque spire doit aboutir à un état quasi commercialisable, permettant une intégration progressive des composants et une meilleure gestion des modifications.