• Aide
  • Eurêkoi Eurêkoi

Livre

Architecture logicielle : pour une approche organisationnelle, fonctionnelle et technique

Résumé

L'ouvrage révèle les liens tissés par les disciplines afférentes à la réalisation d'un projet logiciel d'envergure et permet au lecteur de comprendre comment aboutir à un logiciel qui soit à la fois capable de répondre aux besoins du client ou de réaliser les objectifs métiers de l'entreprise. Les briques fondamentales du big data sont aussi abordées. ©Electre 2016


  • Éditeur(s)
  • Date
    • cop. 2016
  • Notes
    • Contient un "flashcode" permettant d'accéder à un contenu via Internet
  • Langues
    • Français
  • Description matérielle
    • 1 vol. (474 p.) : ill.; ; 21 cm
  • Collections
  • Sujet(s)
  • ISBN
    • 978-2-7460-9921-0
  • Indice
  • Quatrième de couverture
    • Ce livre s'adresse aux DSI, chefs de projets, maîtres d'ouvrage, architectes, administrateurs ou développeurs ; il peut également intéresser les étudiants en informatique ou toute personne impliquée dans un projet logiciel exigeant. Tout au long du livre, l'auteur propose une approche didactique et accessible qui permet de donner au lecteur une vision claire de la dimension architecturale des systèmes informatiques.

      Le livre révèle les liens tissés par les disciplines afférentes à la réalisation d'un projet logiciel d'envergure, agile et réactif. Il permet au lecteur de comprendre comment bâtir un système qui soit à la fois capable de répondre aux besoins du client, de réaliser les objectifs métiers de l'entreprise, tout en optimisant sa production, en facilitant sa maintenance, en s'intégrant aux infrastructures existantes, en rationalisant les coûts et en anticipant sa montée en charge.

      Le lecteur progresse du niveau fonctionnel jusqu'à la technique pure. Il commence par appréhender les processus de développement les plus répandus, qu'ils soient agiles ou formels. Il découvre ensuite les techniques de recueil des exigences et d'élaboration des cas d'utilisation. Il aboutit enfin aux différents concepts d'architectures multi-tiers, distribuées, orientées services/messages et mobiles avant d'approfondir les tests automatisés, la modélisation, la conception orientée objet, la programmation fonctionnelle et les design patterns en passant par les bases de données NoSQL.

      Cette deuxième édition s'enrichit de trois nouveaux chapitres couvrant les briques fondamentales du Big Data, tant au niveau des modes de stockage distribués que des techniques de traitements massivement parallèles, les principes de Lambda-Architecture et le design d'applications réactives grâce à la programmation fonctionnelle.


  • Tables des matières
      • Architecture logicielle

      • Pour une approche organisationnelle, fonctionnelle et technique

      • Avant-propos
      • 1. Objectifs21
      • 2. Public visé22
      • 3. Organisation de l'ouvrage22
      • Chapitre 1 Ingénierie pilotée par les modèles
      • 1. Sémantique introductive23
      • 1.1 Designer25
      • 1.2 Finitude25
      • 1.3 Conjectures26
      • 2. Architecture logicielle27
      • 2.1 Architecte27
      • 2.2 Points clés d'une architecture28
      • 2.3 Challenges28
      • 2.4 Agilité29
      • 2.5 Spécification29
      • 2.5.1 Le System Architecture Document (SAD)29
      • 2.5.2 Le Guide de design des composants30
      • 2.5.3 Le Prototype architectural30
      • 2.5.4 Le Modèle30
      • 2.6 Workflow31
      • 2.6.1 Spécification des exigences31
      • 2.6.2 Analyse architecturale32
      • 2.6.3 Design architectural32
      • 2.6.4 Design orienté objet33
      • 3. Architecture pilotée par les modèles (MDA)33
      • 3.1 Fondations34
      • 3.1.1 MOF34
      • 3.1.2 XMI34
      • 3.1.3 UML35
      • 3.1.4 OCL35
      • 3.2 Architecture MDA35
      • 3.2.1 Cycle de vie du développement35
      • 3.2.2 Modèle indépendant de la plateforme (PIM)36
      • 3.2.3 Modèle spécifique à la plateforme (PSM)37
      • 3.2.4 Code37
      • 3.3 Exemple37
      • 3.3.1 PIM38
      • 3.3.2 PSM base de données38
      • 3.3.3 PSM Java40
      • 3.3.4 Code41
      • 3.4 Conclusion42
      • Chapitre 2 Approche processus
      • 1. Management43
      • 1.1 Arborescence43
      • 1.2 Machine à café44
      • 1.3 Organisation45
      • 1.4 Kanban46
      • 1.5 PMBOK46
      • 2. Processus49
      • 2.1 Manifeste50
      • 2.2 Cycle vertueux51
      • 2.3 Qualité52
      • 2.4 Classification53
      • 2.5 Choix cornélien53
      • 3. Maturité54
      • 4. Épistémologie57
      • 4.1 Le formalisme libère !57
      • 4.2 Waterfall58
      • 4.3 Prototype61
      • 4.4 Spirale62
      • 4.5 Itération64
      • 4.6 SADD65
      • 5. Agilité67
      • 5.1 Manifeste Agile67
      • 5.2 Principes68
      • 5.3 Gourous69
      • 5.4 Le grand mix70
      • 5.5 Détracteurs71
      • Chapitre 3 Méthodes agiles
      • 1. Extreme Programming73
      • 1.1 Quatre valeurs73
      • 1.2 Douze pratiques74
      • 1.2.1 Développement piloté par les tests (TDD)74
      • 1.2.2 Le jeu du planning74
      • 1.2.3 Client dans l'équipe75
      • 1.2.4 Petites livraisons75
      • 1.2.5 Usage des métaphores75
      • 1.2.6 Design simple76
      • 1.2.7 Refactorisation à outrance76
      • 1.2.8 Propriété collective76
      • 1.2.9 Programmation par binômes77
      • 1.2.10 Intégration continue77
      • 1.2.11 Rythme de travail raisonnable77
      • 1.2.12 Conventions de nommage77
      • 1.3 Particularités77
      • 1.3.1 Humanisme77
      • 1.3.2 Vélocité78
      • 1.3.3 YAGNI79
      • 1.3.4 Espace79
      • 1.4 Conclusion79
      • 1.4.1 Architecture émergente80
      • 1.4.2 Exosquelette80
      • 1.4.3 Entropie81
      • 2. Scrum82
      • 2.1 Concept82
      • 2.2 Processus83
      • 2.3 Rôles84
      • 2.3.1 Product Owner84
      • 2.3.2 Team85
      • 2.3.3 Scrum Master85
      • 2.4 Backlog86
      • 2.5 Sprint Planning87
      • 2.6 Daily Scrum88
      • 2.7 Burndown Chart88
      • 2.8 Bénéfices89
      • 2.9 Questions socratiques89
      • 2.10 Tour d'ivoire90
      • 3. Processus Unifié Ouvert (Open UP)91
      • 3.1 Rational Unified Process (RUP)91
      • 3.2 Open UP92
      • 3.3 Principes92
      • 3.4 Organisation93
      • 3.4.1 Zone de contenu93
      • 3.4.2 Rôles94
      • 3.5 Cycle de vie du projet96
      • 3.5.1 Inception96
      • 3.5.2 Élaboration96
      • 3.5.3 Construction96
      • 3.5.4 Transition96
      • 3.6 Itérations97
      • Chapitre 4 Spécifications
      • 1. Exigences101
      • 1.1 Formulations101
      • 1.1.1 Café102
      • 1.1.2 Code102
      • 1.1.3 Tests103
      • 1.1.4 Modèle103
      • 1.1.5 Backlog103
      • 1.1.6 Documents104
      • 1.2 Les parties prenantes104
      • 1.3 Typologie des exigences104
      • 1.3.1 Fonctionnalité105
      • 1.3.2 Exigences fonctionnelles105
      • 1.3.3 Cas d'utilisation105
      • 1.3.4 Prototype106
      • 1.4 Exigences non fonctionnelles106
      • 1.4.1 Disponibilité106
      • 1.4.2 Fiabilité106
      • 1.4.3 Souplesse106
      • 1.4.4 Flexibilité107
      • 1.4.5 Performance107
      • 1.4.6 Montée en charge107
      • 1.4.7 Réutilisation108
      • 1.4.8 Sécurité108
      • 2. Ingénierie108
      • 2.1 Capture108
      • 2.2 Analyse109
      • 2.3 Documentation110
      • 2.4 Validation110
      • 2.5 Gestion110
      • 3. Vision110
      • 3.1 Exigences d'entreprise111
      • 3.1.1 Fondements111
      • 3.1.2 Opportunité commerciale111
      • 3.1.3 Objectifs commerciaux et critères de succès111
      • 3.1.4 Besoins clients112
      • 3.1.5 Risques métier112
      • 3.2 Vision de la solution112
      • 3.2.1 Énoncé de la vision112
      • 3.2.2 Fonctionnalités majeures112
      • 3.2.3 Hypothèses et dépendances112
      • 3.2.4 Périmètre et limitations113
      • 3.2.5 Périmètre de la version initiale113
      • 3.2.6 Périmètre des versions ultérieures113
      • 3.2.7 Limitations et exclusions113
      • 3.3 Contexte métier113
      • 3.3.1 Profil des parties prenantes114
      • 3.3.2 Priorités du projet114
      • 3.3.3 Environnement d'exécution114
      • 4. Spécification114
      • 4.1 Introduction115
      • 4.1.1 Intention115
      • 4.1.2 Conventions115
      • 4.1.3 Audience115
      • 4.1.4 Cadre du projet115
      • 4.1.5 Références115
      • 4.2 Description générale115
      • 4.2.1 Perspective du produit115
      • 4.2.2 Fonctionnalités du produit116
      • 4.2.3 Classes d'utilisateurs116
      • 4.2.4 Environnement opérationnel116
      • 4.2.5 Contraintes de design et d'implémentation116
      • 4.2.6 Documentation utilisateur116
      • 4.2.7 Hypothèses et dépendances116
      • 4.3 Fonctionnalités du système117
      • 4.4 Exigences des interfaces externes118
      • 4.4.1 Interfaces utilisateur118
      • 4.4.2 Interfaces matérielles118
      • 4.4.3 Interfaces logicielles118
      • 4.4.4 Interfaces de communication118
      • 4.4.5 Exigences non fonctionnelles118
      • 4.5 Appendices119
      • 5. Modélisation120
      • 5.1 Modèle fonctionnel120
      • 5.1.1 Exigences120
      • 5.1.2 Reporting121
      • 5.1.3 Diagrammes d'exigences123
      • 5.1.4 Diagrammes de cas d'utilisation123
      • 5.2 Gestion du changement124
      • 5.2.1 Traçabilité125
      • 5.2.2 Matrice126
      • Chapitre 5 Cas d'utilisation
      • 1. Histoires d'usage127
      • 1.1 Historique128
      • 1.2 Terminologie128
      • 1.2.1 Acteur128
      • 1.2.2 Scénario128
      • 1.2.3 Étape129
      • 1.3 Formalisme129
      • 1.3.1 Tout habillé129
      • 1.3.2 Relaxe131
      • 1.4 Rédaction131
      • 1.5 Erreurs classiques132
      • 2. Diagrammes132
      • 3. Use Case points133
      • 3.1 Pourquoi l'utiliser ?133
      • 3.2 Adoption133
      • 3.3 Auteurs134
      • 3.4 Méthode de Karner134
      • 4. Étude de cas138
      • 4.1 Exigences138
      • 4.2 Cas d'utilisation139
      • 4.2.1 Version intégrale139
      • 4.2.2 Version allégée142
      • 4.3 Modèle UML143
      • 4.4 Estimation de coûts144
      • 4.4.1 Estimation145
      • 4.4.2 Conclusion147
      • Chapitre 6 Test et assurance qualité
      • 1. Contexte149
      • 1.1 Utilisation149
      • 1.1.1 Agilité149
      • 1.1.2 Refactorisation151
      • 1.1.3 Intégration continue152
      • 1.2 Granularité154
      • 1.2.1 Tests d'acceptance155
      • 1.2.2 Tests unitaires156
      • 1.3 Plan de test156
      • 1.3.1 Smoke testing157
      • 1.3.2 Positive/Negative testing157
      • 1.3.3 Performance testing157
      • 1.3.4 Stress testing158
      • 1.4 Testabilité158
      • 1.4.1 Membres statiques159
      • 1.4.2 Encapsulation159
      • 1.4.3 Non-MVC159
      • 1.4.4 IOC159
      • 1.4.5 Factory159
      • 2. Outils159
      • 2.1 JUnit159
      • 2.2 JMeter160
      • 2.3 Code coverage161
      • 3. Techniques164
      • 3.1 Boîte noire164
      • 3.1.1 Exemple165
      • 3.1.2 Corollaire de Gödel166
      • 3.2 Boîte blanche167
      • 3.3 Tests d'interface168
      • 3.4 Mock object169
      • Chapitre 7 Architectures d'application
      • 1. Principes d'architecture173
      • 2. Couches173
      • 2.1 Présentation174
      • 2.2 Logique métier175
      • 2.3 Accès aux données175
      • 3. Tier175
      • 3.1 Monolithique176
      • 3.1.1 Mise à jour automatique176
      • 3.1.2 Compatibilité178
      • 3.1.3 Business model178
      • 3.2 Le deuxième tier178
      • 3.3 Architectures n-tier179
      • 3.3.1 Schéma conceptuel179
      • 3.3.2 Avantages180
      • 3.3.3 Linéarité180
      • 3.3.4 Client léger181
      • 3.3.5 Middle-tier181
      • 4. MVC182
      • 4.1 Bénéfices182
      • 4.2 Workflow183
      • 4.3 Différences184
      • 5. Applications mobiles184
      • 5.1 Développement natif185
      • 5.2 Application web186
      • 5.3 Approche hybride186
      • 6. Exemple187
      • 6.1 Architecture187
      • 6.1.1 3-tier187
      • 6.1.2 Modèle MVC188
      • 6.2 Implémentation188
      • 6.2.1 Vue189
      • 6.2.2 Contrôleur192
      • 6.2.3 Modèle194
      • 6.3 Conclusion196
      • Chapitre 8 Architectures d'intégration
      • 1. Paysage IT197
      • 1.1 Évolution des SI197
      • 1.2 Les limites de l'objet198
      • 2. Architecture orientée services (SOA)199
      • 2.1 Le concept de service199
      • 2.2 Vue d'ensemble200
      • 2.3 Service201
      • 2.3.1 Contrat201
      • 2.3.2 Interface201
      • 2.3.3 Implémentation202
      • 2.3.4 Logique métier202
      • 2.3.5 Données202
      • 2.4 Bus de services202
      • 2.4.1 Journalisation204
      • 2.4.2 Sécurité204
      • 2.4.3 Transaction205
      • 2.5 Dépôt de services205
      • 2.5.1 Utilité205
      • 2.5.2 Liaison206
      • 2.6 Application front-end206
      • 3. Technologies207
      • 3.1 Systèmes distribués207
      • 3.1.1 Objets distribués (ORB)207
      • 3.1.2 Middleware orienté messages (MOM)208
      • 3.1.3 Serveurs d'application209
      • 3.2 Services web210
      • 3.2.1 WSDL210
      • 3.2.2 SOAP212
      • 3.2.3 UDDI214
      • 3.2.4 BPMN214
      • 3.2.5 BPEL215
      • 3.3 Restful web services219
      • 3.3.1 Rest219
      • 3.3.2 WADL221
      • 3.4 Stubs et Dispatcher223
      • 3.4.1 Top/Down224
      • 3.4.2 Bottom/Up224
      • 3.4.3 MDA225
      • Chapitre 9 Conception orientée objet
      • 1. L'avènement des objets227
      • 1.1 Quelles sont les différences ?228
      • 1.2 Complexité228
      • 1.2.1 Modularité228
      • 1.2.2 Abstraction229
      • 1.2.3 Polymorphisme229
      • 1.3 Entropie229
      • 2. Principes élémentaires230
      • 2.1 Encapsulation230
      • 2.1.1 Comment l'appliquer ?230
      • 2.1.2 Exemple230
      • 2.2 Cohésion231
      • 2.3 Couplage232
      • 3. Principes avancés232
      • 3.1 Responsabilité unique (SRP)232
      • 3.1.1 Comment l'appliquer ?233
      • 3.1.2 Exemple234
      • 3.2 Ouverture/fermeture (OCP)236
      • 3.2.1 Comment l'appliquer ?236
      • 3.2.2 Exemple 1237
      • 3.2.3 Exemple 2237
      • 3.3 Substitution de Liskov (LSP)238
      • 3.4 Ségrégation d'interfaces (ISP)242
      • 3.5 Inversion de dépendances (DIP)243
      • 3.6 Inversion de contrôle (IOC)246
      • 3.6.1 Service locator247
      • 3.6.2 Injection par container248
      • 4. Conclusion250
      • Chapitre 10 Stockages distribués
      • 1. Introduction251
      • 2. Big Data et scalabilité252
      • 2.1 Les enjeux252
      • 2.2 Les nouveaux métiers253
      • 2.3 Les cas d'usage254
      • 2.3.1 Modélisation des risques254
      • 2.3.2 Analyse de la perte des clients (churn)255
      • 2.3.3 Moteur de recommandations255
      • 2.3.4 Ciblage publicitaire255
      • 2.3.5 Prédiction de pannes par analyse réseau256
      • 2.3.6 Détection de fraudes256
      • 2.3.7 Recherche256
      • 2.3.8 Bac à sable257
      • 2.4 Les distributions257
      • 2.5 Les grands acteurs257
      • 3. Hadoop et le Big Data258
      • 3.1 HDFS : un système de fichiers distribué259
      • 3.1.1 Architecture HDFS261
      • 3.1.2 Réplication des données262
      • 3.2 Paradigme MapReduce262
      • 3.3 Orchestration des jobs avec YARN264
      • 3.4 Un exemple en Java266
      • 4. Stockages NoSQL268
      • 4.1 NoSQL ou la fin des formes normales269
      • 4.2 Schémas et formats de sérialisation270
      • 4.2.1 Protocoles d'échange de données270
      • 4.2.2 Apache Parquet273
      • 4.3 HBase, une base de données clé/valeur orientée colonnes275
      • 4.4 Lucene et les moteurs de recherche277
      • 4.4.1 Les annuaires inversés278
      • 4.4.2 Le sharding pattern283
      • 4.5 Bases de données orientées graphes284
      • 4.5.1 Que peut-on faire avec des graphes ?285
      • 4.5.2 Quid des performances ?287
      • Chapitre 11 Traitements et architectures distribués
      • 1. Introduction289
      • 2. Écosystème Hadoop289
      • 2.1 Acquisition des données290
      • 2.1.1 Sqoop290
      • 2.1.2 Flume292
      • 2.1.3 Storm296
      • 2.1.4 Kafka298
      • 2.2 Traitements300
      • 2.2.1 Pig300
      • 2.2.2 Hive301
      • 2.3 Traitements itératifs avec Spark302
      • 2.3.1 Faiblesses d'Hadoop302
      • 2.3.2 Jeux de données résilients et distribués (RDD)303
      • 2.3.3 Modèle d'exécution305
      • 2.3.4 MapReduce avec Spark306
      • 3. Lambda-Architecture307
      • 3.1 Principes et avantages308
      • 3.1.1 Batch layer309
      • 3.1.2 Realtime layer310
      • 3.1.3 Serving layer311
      • 3.2 Conclusions311
      • 3.3 Pile technologique312
      • 3.4 Architecture log-centric312
      • 3.4.1 Concept de log313
      • 3.4.2 Systèmes distribués314
      • 3.4.3 Intégration des données315
      • Chapitre 12 Modélisation
      • 1. Merise317
      • 1.1 Origine318
      • 1.2 Cycle de vie318
      • 1.3 Modèle conceptuel de données (MCD)319
      • 1.3.1 Entités319
      • 1.3.2 Associations320
      • 1.3.3 Cardinalités321
      • 1.3.4 Dimension322
      • 1.3.5 Méthode323
      • 1.3.6 Formes normales324
      • 1.4 Modèle logique des données (MLD)325
      • 1.4.1 Tables325
      • 1.4.2 Relations n/m326
      • 1.4.3 Relations 1/n327
      • 1.5 Modèle physique des données (MPD)327
      • 2. UML328
      • 2.1 Modèles et vues330
      • 2.2 Éléments330
      • 2.2.1 Classe331
      • 2.2.2 Interface333
      • 2.2.3 Package334
      • 2.2.4 Composant334
      • 2.2.5 Noeud335
      • 2.2.6 État335
      • 2.3 Relations336
      • 2.3.1 Types336
      • 2.3.2 Multiplicité337
      • 2.4 Notes et stéréotypes338
      • 2.5 Diagrammes339
      • 2.5.1 Diagramme de classes340
      • 2.5.2 Diagramme de structure composite341
      • 2.5.3 Diagramme de composants342
      • 2.5.4 Diagramme de déploiement343
      • 2.5.5 Diagramme d'objets344
      • 2.5.6 Diagramme de packages344
      • 2.5.7 Diagramme de profils345
      • 2.5.8 Diagramme d'activité346
      • 2.5.9 Diagramme de cas d'utilisation347
      • 2.5.10 Machine à états348
      • 2.5.11 Diagramme de timing349
      • 2.5.12 Diagramme de séquence349
      • 2.5.13 Diagramme de communication351
      • 2.5.14 Diagramme global d'interaction352
      • Chapitre 13 Design patterns
      • 1. Introduction355
      • 1.1 Genèse356
      • 1.2 Origine356
      • 1.3 Définition357
      • 1.4 Intérêt357
      • 1.5 Formalisme358
      • 2. Patterns359
      • 2.1 Création360
      • 2.1.1 Abstract Factory360
      • 2.1.2 Builder362
      • 2.1.3 Factory Method364
      • 2.1.4 Prototype365
      • 2.1.5 Singleton367
      • 2.2 Structure368
      • 2.2.1 Adapter368
      • 2.2.2 Bridge370
      • 2.2.3 Composite371
      • 2.2.4 Decorator373
      • 2.2.5 Facade374
      • 2.2.6 Flyweight376
      • 2.2.7 Proxy377
      • 2.3 Comportement379
      • 2.3.1 Chain of Responsibility379
      • 2.3.2 Command381
      • 2.3.3 Interpreter382
      • 2.3.4 Iterator384
      • 2.3.5 Mediator385
      • 2.3.6 Memento387
      • 2.3.7 Observer388
      • 2.3.8 State389
      • 2.3.9 Strategy390
      • 2.3.10 Template Method392
      • 2.3.11 Visitor393
      • Chapitre 14 Programmation fonctionnelle
      • 1. Introduction397
      • 2. Programmation fonctionnelle397
      • 2.1 Brève introduction à Scala398
      • 2.1.1 Mutable/Immutable399
      • 2.1.2 Fonction399
      • 2.1.3 Une classe simple399
      • 2.1.4 Les collections400
      • 2.1.5 Les itérations400
      • 2.1.6 Fonctions récursives401
      • 2.1.7 Petit script pour compter les mots dans un fichier401
      • 2.2 Principes de programmation fonctionnelle402
      • 2.2.1 Effets de bord402
      • 2.2.2 Transparence référentielle et fonctions pures404
      • 2.2.3 Des états immutables406
      • 2.2.4 Options et pattern matching407
      • 2.2.5 Boucles for-comprehension408
      • 2.2.6 Fainéantise et structures infinies408
      • 3. Théorie des catégories et design patterns409
      • 3.1 Monoïdes410
      • 3.1.1 Quelques exemples mathématiques simples410
      • 3.1.2 Généralisation de la première équation : la fermeture411
      • 3.1.3 Généralisation de la deuxième équation : l'associativité412
      • 3.1.4 Généralisation de la troisième équation : l'élément neutre412
      • 3.1.5 Récapitulatif413
      • 3.1.6 Usage des monoïdes413
      • 3.1.7 Définition théorique en Scala414
      • 3.2 Monades415
      • 3.2.1 Un exemple concret416
      • 3.2.2 La monade Option[T]417
      • 3.2.3 Utilisation fonctionnelle de la monade Option418
      • 3.2.4 Travail sur les listes et les boucles for-comprehension419
      • 3.2.5 Try[T] au secours des exceptions420
      • 3.2.6 Définition théorique d'une monade424
      • 3.2.7 Les lois des monades425
      • 4. Systèmes réactifs427
      • 4.1 Reactive manifesto428
      • 4.2 Le modèle d'acteurs430
      • 4.2.1 Concepts fondamentaux430
      • 4.2.2 Un système d'acteurs431
      • 4.2.3 Un exemple avec Akka431
      • 4.2.4 Conclusion433
      • Chapitre 15 Boîte à outils
      • 1. Métrologie435
      • 1.1 Productivité435
      • 1.1.1 Métriques d'ordre général436
      • 1.1.2 Lignes de code (LOC)436
      • 1.2 Qualité du design437
      • 1.2.1 Complexité cyclomatique437
      • 1.2.2 Couplage entre objets (CBO)437
      • 1.2.3 Manque de cohésion des méthodes (LCOM)438
      • 1.3 Qualité de service438
      • 1.3.1 Durée moyenne de panne (MTTF)438
      • 1.3.2 Défauts par ligne de code438
      • 1.4 Exemple439
      • 1.4.1 Classe à l'étude439
      • 1.4.2 Résultats441
      • 2. Outils CASE442
      • 2.1 Références443
      • 2.1.1 ArgoUML443
      • 2.1.2 Rational software443
      • 2.1.3 PowerAMC443
      • 2.1.4 Objecteering444
      • 2.1.5 Enterprise Architect444
      • 2.2 Génie logiciel444
      • 2.2.1 Génération de code444
      • 2.2.2 Reverse engineering450
      • 2.2.3 Synchronisation452
      • 2.3 Documentation452
      • 2.4 Analyse d'exécution452
      • 3. Traité d'esthétisme453
      • 3.1 Théorie constructale453
      • 3.2 Le nombre d'or454
      • 3.3 Émergence455
      • Bibliographie457
      • Index459

  • Origine de la notice:
    • Electre
  • Disponible - 652.4 BAI

    Niveau 3 - Gestion