Applications logicielles certifiables. 3 , Cycle descendant

Auteur(s) :

Boulanger, Jean-Louis (1966-....) Découvrir l'auteur

Résumé

Description du processus de réalisation d'une application logicielle et de sa phase descendante afin d'identifier en amont les défauts. Avec une présentation pour chaque phase, de la spécification à la production du code, des activités de conception, de préparation des tests et de vérification à mettre en oeuvre. ©Electre 2018

Éditeur(s)
- Iste éditions
Date
- cop. 2018
Langues
- Français
Description matérielle
- 1 vol. (XI-331 p.) : ill. en coul., fig. ; 24 cm
Collections
- Informatique
Sujet(s)
ISBN
- 978-1-78405-515-8
Indice
- 681.2 Programmation (généralités)
Quatrième de couverture
- Applications logicielles certifiables se compose de plusieurs ouvrages qui présentent le développement d'une application logicielle critique.
  Ce troisième opus décrit le processus de réalisation d'une application logicielle en se focalisant sur la phase descendante. Le cycle de vie pris comme référence est le cycle en V. Ce cycle se veut le plus agile possible. La préparation des tests se fait donc lors de la phase descendante et permet d'identifier très tôt des défauts. Pour chaque phase, de la spécification à la production du code, les activités de conception, de préparation des tests et de vérification à mettre en place sont également présentées.
  Dans cet ouvrage le lecteur trouvera une description essentielle et complète de la réalisation d'une application logicielle qui doit être mis en oeuvre, afin que celle-ci soit la plus sûre possible.
Tables des matières
- - Applications logicielles certifiables 3
  - Cycle descendant
  - Jean-Louis Boulanger
  - iSTE éditions
  - Introduction 1
  - Chapitre 1. Réalisation d'une application logicielle3
  - 1.1. Introduction3
  - 1.2. Processus de réalisation3
  - 1.3. Maîtrise de la qualité5
  - 1.3.1. Introduction5
  - 1.3.2. Plan d'assurance qualité du logiciel6
  - 1.4. Conclusion7
  - Chapitre 2. Gestion des exigences9
  - 2.1. Introduction9
  - 2.2. Trois notions essentielles10
  - 2.2.1. Introduction10
  - 2.2.2. Exigence de processus10
  - 2.2.3. Présentation du concept d'exigence11
  - 2.2.4. Attributs14
  - 2.2.5. Allocation versus raffinement17
  - 2.2.6. Traçabilité19
  - 2.3. Processus22
  - 2.3.1. Introduction22
  - 2.3.2. Deux approches23
  - 2.3.3. Mise en place d'outils25
  - 2.4. Conclusion26
  - Chapitre 3. Structure documentaire29
  - 3.1. Introduction29
  - 3.2. Documentation29
  - 3.2.1. Introduction29
  - 3.2.2. Formalisation des documents30
  - 3.2.3. Signature et acceptation30
  - 3.3. Maîtrise de la qualité31
  - 3.3.1. Processus qualité de l'entreprise31
  - 3.3.2. Maîtrise de la qualité du projet32
  - 3.4. Processus de réalisation35
  - 3.5. Gestion de la configuration36
  - 3.6. Gestion des anomalies et des non-conformités36
  - 3.6.1. Présentation36
  - 3.6.2. Formalisation des défauts37
  - 3.6.3. Impact des évolutions37
  - 3.7. Conclusion40
  - Chapitre 4. Spécification des exigences d'une application logicielle41
  - 4.1. Introduction41
  - 4.2. Gestion des exigences42
  - 4.2.1. Présentation42
  - 4.2.2. Gestionnaire des exigences43
  - 4.3. Savoir spécifier44
  - 4.4. Caractéristiques qualité d'un produit logiciel46
  - 4.5. Objectifs de la phase de spécification des exigences du logiciel48
  - 4.6. Prise en compte des risques53
  - 4.7. Document de spécification des exigences du logiciel : SEL54
  - 4.7.1. Présentation54
  - 4.7.2. Caractérisation du contenu du DSL54
  - 4.7.3. Identification de la bordure du logiciel55
  - 4.7.4. Identification des modes de fonctionnement57
  - 4.7.5. Identification des données de paramétrages60
  - 4.7.6. Identification des services/fonctions61
  - 4.7.7. Description du comportement61
  - 4.8. Formalisation des spécifications64
  - 4.8.1. Modélisation pour la vérification64
  - 4.8.2. Spécification textuelle versus spécification graphique66
  - 4.8.3. Méthode formelle67
  - 4.9. Prise en compte des COTS et des composants réutilisés67
  - 4.10. Vérification de la spécification68
  - 4.11. Conclusion68
  - 4.12. Annexe A : plan type d'une SEL68
  - Chapitre 5. Modélisation71
  - 5.1. Introduction71
  - 5.2. Modélisation71
  - 5.2.1. Présentation71
  - 5.2.2. Modèle72
  - 5.2.3. Différents types de modélisation77
  - 5.3. Transformation de modèle77
  - 5.3.1. Présentation77
  - 5.3.2. Différents types de transformation78
  - 5.3.3. Abstraction79
  - 5.3.4. Réalisation81
  - 5.3.5. Transformation d'élément82
  - 5.3.6. Génération de code84
  - 5.3.7. Bilan85
  - 5.4. Raffinement de modèle86
  - 5.5. Méthodes87
  - 5.5.1. Méthode semi-formelle87
  - 5.5.2. Méthode structurée89
  - 5.5.3. Méthode formelle89
  - 5.5.4. Outils de spécification assistés par ordinateur90
  - 5.5.5. Bilan90
  - 5.6. Conclusion91
  - Chapitre 6. Formalisation93
  - 6.1. Introduction93
  - 6.2. Exemple d'approche93
  - 6.2.1. Diagramme de contexte93
  - 6.2.2. Méthode structurée98
  - 6.2.3. Modélisation102
  - 6.2.4. Méthode et/ou technique formelles116
  - 6.2.5. Synthèse137
  - 6.3. Vérification de modèle137
  - 6.4. Mise en place des méthodes formelles138
  - 6.5. Mise en oeuvre des méthodes formelles140
  - 6.5.1. Processus classiques140
  - 6.5.2. Processus prenant en compte les méthodes formelles141
  - 6.5.3. Problématique143
  - 6.6. Maintenance de l'application logicielle145
  - 6.7. Conclusion146
  - Chapitre 7. Vérification de la phase de spécification d'une application logicielle149
  - 7.1. Introduction149
  - 7.2. Vérification149
  - 7.2.1. Présentation149
  - 7.2.2. Vérifications de la spécification des exigences du logiciel150
  - 7.2.3. Synthèse163
  - 7.3. Conclusion164
  - Chapitre 8. Composant versus module165
  - 8.1. Introduction165
  - 8.2. Réutilisabilité, maintenabilité et continuité de service166
  - 8.3. Module et composant168
  - 8.3.1. Présentation168
  - 8.3.2. Module168
  - 8.3.3. Composant171
  - 8.3.4. Encapsulation des données versus masquage d'information173
  - 8.4. Conclusion173
  - Chapitre 9. Architecture d'une application logicielle175
  - 9.1. Introduction175
  - 9.2. Objectif de la phase d'architecture d'une application logicielle175
  - 9.3. Architecte logiciel178
  - 9.4. Dossier de description de l'architecture du logiciel : DDAL179
  - 9.4.1. Introduction179
  - 9.4.2. Contrainte sur la méthodologie179
  - 9.4.3. Description des interfaces avec l'environnement179
  - 9.4.4. Architecture type180
  - 9.4.5. Composant, module et interface182
  - 9.4.6. Principe d'architecture184
  - 9.4.7. Description de l'architecture de l'application logicielle195
  - 9.5. Vérification de l'architecture de l'application logicielle199
  - 9.6. Prise en compte des COTS et des composants réutilisés200
  - 9.6.1. Introduction200
  - 9.6.2. Composant pré-existant201
  - 9.6.3. COTS201
  - 9.6.4. Réutilisabilité202
  - 9.7. Modèle approche203
  - 9.8. Conclusion205
  - Chapitre 10. Vérification de l'architecture logicielle207
  - 10.1. Introduction207
  - 10.2. Vérification207
  - 10.2.1. Rappel207
  - 10.2.2. Vérifications de l'architecture de l'application logicielle208
  - 10.2.3. Synthèse220
  - 10.3. Conclusion221
  - Chapitre 11. Conception de l'application logicielle223
  - 11.1. Introduction223
  - 11.2. Composant223
  - 11.3. Objectif de la phase de conception224
  - 11.4. Concepteur226
  - 11.5. Dossier de spécification du composant logiciel226
  - 11.5.1. Objectif226
  - 11.5.2. Contrainte sur la méthodologie227
  - 11.5.3. Caractéristique de la méthodologie227
  - 11.6. Dossier de spécification du composant logiciel : DSCL228
  - 11.6.1. Principes228
  - 11.6.2. Décomposition des fonctions230
  - 11.6.3. Décomposition en module ou unité de programmation230
  - 11.6.4. Description des données232
  - 11.6.5. Description des algorithmes232
  - 11.6.6. Traçabilité des exigences233
  - 11.7. Vérification de la conception235
  - 11.8. Prise en compte des COTS et des composants réutilisés236
  - 11.8.1. Introduction236
  - 11.8.2. Code pré-existant236
  - 11.8.3. COTS237
  - 11.9. Conclusion237
  - Chapitre 12. Vérification de la phase de conception des composants de l'application logicielle239
  - 12.1. Introduction239
  - 12.2. Vérification239
  - 12.2.1. Rappel239
  - 12.2.2. Vérifications de la conception des composants d'une application logicielle240
  - 12.2.3. Synthèse248
  - 12.3. Conclusion249
  - Chapitre 13. Codage de l'application logicielle251
  - 13.1. Introduction251
  - 13.2. Objectif de la phase de codage252
  - 13.3. Implémenteur - Codeur253
  - 13.4. Production du code254
  - 13.4.1. Codage manuel ou génération automatique254
  - 13.4.2. Chaîne de génération de l'exécutable256
  - 13.5. Principes à mettre en oeuvre dans le cadre de la phase de codage256
  - 13.5.1. Respect du DCCL257
  - 13.5.2. Règles de programmation257
  - 13.6. Choix du langage de conception260
  - 13.6.1. Introduction260
  - 13.6.2. Propriétés essentielles260
  - 13.6.3. Analyse des langages262
  - 13.7. Prise en compte des COTS et des composants réutilisés272
  - 13.8. Vérification de la phase de codage273
  - 13.9. Conclusion273
  - Chapitre 14. Règles de programmation275
  - 14.1. Introduction275
  - 14.2. Caractéristiques des règles de programmation275
  - 14.2.1. Introduction275
  - 14.2.2. Règles générales278
  - 14.2.3. Règles de compilation278
  - 14.2.4. Règles de mise en forme279
  - 14.2.5. Règles de documentation279
  - 14.2.6. Règles de génie logiciel280
  - 14.2.7. Nommage des objets282
  - 14.2.8. Gestion des variables284
  - 14.2.9. Règles liées aux principes de sécurité286
  - 14.3. Vérification des règles de programmation287
  - 14.4. Conclusion287
  - Chapitre 15. Vérification du codage289
  - 15.1. Introduction289
  - 15.2. Vérification289
  - 15.2.1. Rappel289
  - 15.2.2. Méthodologie289
  - 15.2.3. Respect des règles de codage291
  - 15.3. Code mort et code inatteignable292
  - 15.3.1. Introduction292
  - 15.3.2. Code inatteignable293
  - 15.3.3. Code mort293
  - 15.3.4. Code inhibé294
  - 15.4. Conclusion294
  - Chapitre 16. Fiche de version de l'application logicielle295
  - 16.1. Introduction295
  - 16.2. Génération de l'exécutable : principes295
  - 16.3. Identification de l'exécutable297
  - 16.3.1. Introduction297
  - 16.3.2. Identification de l'exécutable298
  - 16.3.3. Protection de l'exécutable298
  - 16.4. Fiche de version de l'application logicielle298
  - 16.4.1. Présentation du besoin298
  - 16.4.2. Mise en oeuvre299
  - 16.4.3. Compatibilité300
  - 16.4.4. Bilan300
  - 16.5. Conclusion301
  - 16.6. Annexe B : fiche de version du logiciel301
  - Conclusion et perspectives 303
  - Glossaire 305
  - Bibliographie 311
  - Index 321
  - Sommaires des autres volumes 325
Origine de la notice:
- Electre