Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Informatique Kolyang Introduction au génie logiciel Analyse des besoins validat

Informatique Kolyang Introduction au génie logiciel Analyse des besoins validation conception intégration implémentation S c i e n c e Ka arang Introduction au génie logiciel de Kolyang Université de Ngaoundéré, Cameroun © Kolyang et Ka’arang : Editions et Média, 2006 Affiliation : Dr.-Ing. Kolyang Département de Mathématiques et Informatique Faculté des Sciences Université de Ngaoundéré 2 Table des matières Chapitre 1 : Introduction générale...................................................................... 5 1.1 Définitions.................................................................................................................................................................. 6 1.2 Facteurs de production................................................................................................................................................8 1.3 Les facteurs de grandeur du projet..............................................................................................................................8 1.4 Facteurs internes et externes.......................................................................................................................................9 1.4.1 Facteurs externes................................................................................................................................................. 9 1.4.2 Facteurs internes et modularité..........................................................................................................................10 1.4.3 Facteurs de qualité et de productivité................................................................................................................12 1.5 Aspects de gestion.................................................................................................................................................... 13 Chapitre 2 : Historique sur le développement du logiciel.................................. 14 2.1 Contexte historique..................................................................................................................................................14 2.2. Génie Logiciel......................................................................................................................................................... 16 2.3. Méthodes (semi-)formelles .....................................................................................................................................17 2.4. Structuration et abstraction : concepts essentiels.....................................................................................................18 2.5. Modélisation dans le développement des systèmes ................................................................................................18 Chapitre 3 : Les modèles du développement des logiciels................................. 20 3.1 Rappels historiques...................................................................................................................................................20 3.2 Les modèles de développement ...............................................................................................................................21 3.2.1 Modèle en cascade.............................................................................................................................................22 3.2.2 Développement évolutif (à incréments).............................................................................................................23 3.2.3 Modèle en spirale.............................................................................................................................................. 25 3.2.4 Modèles spécifiques.......................................................................................................................................... 27 3.3 Evaluation des procédés........................................................................................................................................... 29 Chapitre 4 : Analyse et définition des besoins................................................... 31 4.1 Structuration de l’analyse des besoins......................................................................................................................33 4.2 Validation des Besoins............................................................................................................................................. 35 4.3 Exemple de cahier de charges..................................................................................................................................37 Chapitre 5 : Gestions des versions et des configurations.................................. 43 5.1. Lois de Lehman ...................................................................................................................................................... 43 5.2 Identification des versions ....................................................................................................................................... 46 5.3 Notions de base du versionnage .............................................................................................................................. 47 5.4. La gestion de la configuration................................................................................................................................. 49 5.5 Nature des changements........................................................................................................................................... 50 5.5.1 Les cas classiques.............................................................................................................................................. 51 5.5.2 Cas des progiciels.............................................................................................................................................. 52 Chapitre 6 : Modélisation avec les méthodes semi-formelles............................ 54 6.1. Définition.................................................................................................................................................................54 6.2 Modélisation Entity/Relationship (ER).................................................................................................................... 55 6.3 Diagramme de flux de données................................................................................................................................ 56 6.4 Les modèles de classe ..............................................................................................................................................58 6.5 Modélisation Orientée Objet.................................................................................................................................... 59 6.6 Une introduction à UML ......................................................................................................................................... 59 6.7 Cas d’utilisation........................................................................................................................................................60 Chapitre 7 : La modélisation des classes .......................................................... 65 7.1 Les diagrammes des classes......................................................................................................................................65 7.2 Les classes............................................................................................................................................................... 67 7.2.1 L’identification des classes................................................................................................................................67 7.2.2 Les associations................................................................................................................................................. 69 Chapitre 8 : Modélisation formelle avec Z ......................................................... 71 8.1. Z...............................................................................................................................................................................71 8.2 Un exemple introductif : The Birthday Book...........................................................................................................73 8.3 Modélisation des données avec Z et les diagrammes ER......................................................................................... 76 8.3.1 Equivalence et schémas..................................................................................................................................... 77 8.3.2 Les opérateurs et le calcul des schémas.............................................................................................................79 8.4 Raffinement du Birthday Book.................................................................................................................................81 8.5 Queens Problem (Problème des reines)....................................................................................................................83 Chapitre 9 : Des modèles aux codes.................................................................. 85 3 9.1 Structuration, contexte et historique.........................................................................................................................85 9.2 Structuration dans le langage orienté objet...............................................................................................................86 9.3 Classes versus module.............................................................................................................................................. 86 9.3.1 Les interfaces ....................................................................................................................................................86 9.3.2 Les types et le polymorphisme.......................................................................................................................... 87 9.3.3 L’héritage ..........................................................................................................................................................87 9.4 Du code à partir des diagrammes de classe.............................................................................................................. 88 9.4.1 Les diagrammes de classe..................................................................................................................................88 9.4.2 La généralisation ...............................................................................................................................................89 9.4.3 Les associations ................................................................................................................................................ 89 9.5 Génération de codes à partir de Z.............................................................................................................................90 9.5.1 Les types de données ........................................................................................................................................ 90 9.5.2 les relations........................................................................................................................................................91 9.5.3 Les schémas .....................................................................................................................................................91 9.5.4 Les techniques de structuration..........................................................................................................................91 Chapitre 10 : les interfaces graphiques............................................................. 93 10.1 Aperçu sur les interfaces graphiques...................................................................................................................... 93 10.2 Recommandations de développement.................................................................................................................... 94 10.3 Technologies concrètes : Java /swing ....................................................................................................................96 10.4 Conclusion .............................................................................................................................................................98 Chapitre 11 : La validation et le test des logiciels ............................................ 99 11.1 Vérification et transformation.................................................................................................................................99 11.2 Validation des programmes par inspection...........................................................................................................100 11.3 Le test .................................................................................................................................................................. 101 11.3.1 Différents niveaux de test.............................................................................................................................. 103 11.3.2 Automatisation du test .................................................................................................................................. 104 11.4 Couverture de code...............................................................................................................................................105 Exercices d’application.................................................................................... 107 Questions de cours........................................................................................................................................................108 Sujets d’examen.............................................................................................. 112 Examen 1...................................................................................................................................................................... 112 Examen 2...................................................................................................................................................................... 112 Examen 3...................................................................................................................................................................... 113 Examen 4...................................................................................................................................................................... 114 Bibliographie .................................................................................................. 115 4 Chapitre 1 : Introduction générale L’ingénierie, dans sa compréhension générale et publique, n’est pas possible pour le logiciel. Un ingénieur peut construire un pont, étant convaincu qu’il répond aux exigences et au modèle conçu. En informatique, la théorie et les outils ne sont pas encore assez bons pour permettre de construire des logiciels qui répondent à ce standard. Le présent document a des objectifs moins ambitieux. Il discute des méthodes de « fabrication » et de conception systématique de logiciels. Le processus de développement de logiciel est connu pour être très pernicieux. Au centre de ces procédés d’étude et de réalisation se trouve la programmation. Tout logiciel ne vient à l’existence qu’avec la codification dans un langage. La programmation est la description d’un calcul de manière à l’exécuter sur une machine. L’on distingue généralement la programmation in-the-small de la programmation in-the-large. La programmation in-the- small concerne l’écriture de code pour résoudre des tâches claires et précises. En implémentant couche par couche, l’on se retrouve généralement en train de réaliser la programmation in-the-large : couler ensemble de larges modules pour résoudre des tâches probablement mal définies. Ceci devient alors un défi si les modules n’ont pas été préalablement conçus pour fonctionner ensemble. C’est l’une des principales tâches du software engineering, le génie logiciel. Pour mener à bien ces besognes, les programmeurs ont besoin de plusieurs qualités, pour communiquer les exigences (requirements), afin de résoudre le bon problème, analyser les problèmes, les divisant en petites sous-tâches, organiser les solutions d’une manière sensible, afin qu’elles se laissent comprendre et se changer facilement, estimer les coûts, en sachant à l’avance si une approche donnée est faisable ou non et enfin utiliser les mathématiques pour arriver à des solutions correctes et simples. Dans sa compréhension comme technologie, le génie logiciel s’occupe de toutes ces exigences. Une application de grande envergure en opposition à un logiciel pour une utilisation individuelle a plusieurs utilisateurs et souvent plusieurs développeurs et techniciens qui en assurent la maintenance. Dans plusieurs de ces cas, les développeurs, les usagers et les agents de maintenance sont tous différents. Dans ce sens, le développement et la maintenance d’une application logicielle nécessitent une approche beaucoup plus systématique qu’un logiciel d’utilisation individuelle. 5 La nécessité d’approches systématiques de développement du logiciel se fait sentir dans les années 1960. Pendant cette décade, le matériel informatique de la troisième génération est inventée et les logiciels systèmes de multi-programming et du time-sharing sont développés. Ces facilités ont introduit la technologie d’une implantation des systèmes informatiques multi-utilisateur, en ligne et en temps réel. De nouvelles applications sont développées tels les logiciels de réservation pour les lignes aériennes, les systèmes d’information médicale, le contrôle des processus, les applications militaires etc. Plusieurs de ces systèmes ont été implantés et utilisés, plusieurs autres tentatives n’ont jamais été réellement mises en service. Parmi celles réceptionnées, plusieurs étaient sujets à des coûts prohibitifs par dépassement du budget, réception tardive, inefficacité, et manque d’acceptance par l’utilisateur. Quand les systèmes informatiques devenaient de plus en plus larges et complexes, l’on réalisa que la demande pour les logiciels devenait de plus en plus pressante, et largement au-dessus des capacités de production. A deux conférences, en 1968 en Allemagne et en 1969 en Italie, organisées par l’OTAN, la notion de Software Engineering fut émise pour souligner la nécessité d’avoir des techniques relevant de l’ingénierie pour pouvoir résoudre le problème de production de logiciel. Aussi la notion de software crisis (crise du logiciel) vit le jour. Selon Boehm (1976), le génie logiciel concerne «the practical application of scientific knowledge to the design and construction of computer programs and the associated documentation required to develop, operate, and maintain them ». Une autre approche de définition proposée par l’IEEE rapporte que le software engineering est : « the systematic approach to the development, operation, maintenance, and retirement of software » pendant que le logiciel (software) est défini comme “computer programs, procedures, rules, and possibly associated documentation and data pertaining to the operation of a computer system”. Le génie logiciel est une discipline technologique basée sur les fondements de l’informatique, de la gestion, de l’économie, des techniques de communication et de l’approche d’ingénierie pour la solution des problèmes. Le génie logiciel est fondé sur l’informatique pour y puiser les bases scientifiques tout comme le génie électrique ou le génie chimique sont fondés sur la physique ou la chimie. 1.1 Définitions Le génie logiciel diffère de la traditionnelle programmation par le fait qu’il utilise des techniques et méthodes de l’ingénierie pour spécifier, concevoir, implémenter, valider et maintenir des produits logiciels dans un 6 temps fixé et des contraintes budgétaires établies par le projet. Ensuite, le génie logiciel obéit à des techniques de gestion qui sont en dehors du domaine de la programmation traditionnelle. Dans un projet incluant plusieurs programmeurs sur de longues périodes, le contrôle de gestion doit s’occuper de la coordination de ces activités techniques. Le programmeur est un individu concerné par les détails de l’implémentation, la modification des structures de données et des algorithmes écrits dans un langage de programmation. Les ingénieurs du logiciel doivent en plus prêter attention à l’analyse, la conception, la vérification et le test, la documentation, la maintenance du logiciel et la gestion du projet. Les ingénieurs du logiciel doivent avoir considérablement de l’expérience en tant que programmeurs pour bien estimer les domaines du problème, les buts et objectifs. Le terme computer software ou logiciel est souvent synonyme de programme ou de code source. Souvent, il est aussi synonyme de produit. Ainsi le logiciel inclut le code source, tous les documents associés et enfin uploads/Management/ genie-logiciel-cours-in303.pdf