CM6
#49-68 : cycles de dev ?
Cycles de dev.
1. Cycle en cascade :
- étapes successives, comme en bâtiments : on ne construit pas le toit avant les fondations... enfin... pas toujours...
- tests/validation à la fin de chaques phases
- Etapes:
- Faisabilité : go/no go / doc: avant projet
- Conception : validation / doc : specs fonctionelles / techniques (2 étapes)
- Réalisation : tests : composant.
- Déploiement : vérifications
En pratique réalité boff...
Cycle en V, importance des tests.
Expr. du besoin -> recette utilisateur
Conception générale -> recette fonctionnelle
Conception architecture -> test intégration
Conception détaillée -> tests unitaires
Réalisation.
-> cascade puis remonte.
- Utilisateur/MOA/MOE
- Opérationnel / Conceptuel / Architectural / descriptif / Physique.
Mais... effet tunnel.
Utilisateur voit début et la fin -> donc si un problème coûte cher.
E.g. mauvaise formulation/compréhension des specs.
Si tunnel long (des années), besoin peut avoir évolué.
-> peut de marge de manoeuvre pour modifier, on est déjà à la fin du projet.
Budget consommé, plus de temps.
Cycle en W : 2 cycles en V, pour établir un prototype/PoC.
Coûteux, on peut se contenter de maquettes statiques/description IHM.
Approprié pour des projets donc les besoins ne changent pas, et domaines très sensibles : e.g. aéronotique.
Cycles itératifs :
- Réalisation pour itérations successives (~= mini-cycles en V + étape de transition), fonctionnalités centrales puis on ajoute.
-> permet de s'assurer que les fonctionnalités de bases fonctionnent + permet d'avoir retours users rapidement. Peut impliquer l'utilisateur dans la conception.
- plus compliqué à planifier... mais vu que les plannings sont généralement peu tenus, la flexibilité est bien.
Méthode agile (ensembles de valeurs): cycles itératifs, passé un temps très "tendance".
-> réduit les documents techniques (death by UML fever)
-> réduits les réunions à rallonge.
-> feedback continu.
-> pas conception entière au début.
-> itération = 1 sprint.
https://manifesteagile.fr/
https://agilemanifesto.org/
-> scrum (méthodes)
-> xtreme Programming
-> lean
-> et plein d'autres.
Avec des puristes -> mais si trop doctrine pas agile.
Honnêtement on s'en fou : choisir l'outil qui convient, faire un mix ou autre.
///
Scrum est un framework Agile structuré centré sur des cycles courts et réguliers.
🔧 Principes clés
Travail en sprints (1 à 4 semaines)
Rôles définis : Product Owner, Scrum Master, Développeurs
Artefacts : Product Backlog, Sprint Backlog, Incrément
Événements obligatoires : Daily, Sprint Planning, Review, Rétrospective
L’équipe s’engage sur un objectif de sprint
🎯 Objectif
Fournir régulièrement un incrément utilisable du produit.
💡 Caractéristiques typiques
Cadre très codifié
Orientation organisation et collaboration
Planification à court terme mais rituels stricts
///
2. Extreme Programming (XP)
XP (Extreme Programming) est une méthode Agile axée sur la qualité du code et les pratiques techniques.
🔧 Principes clés
Tests automatisés (TDD : Test-Driven Development)
Pair programming (2 devs, 1 clavier)
Refactoring continu
Intégration continue
Petites releases fréquentes (itérations d’une semaine)
Présence du client (ou représentant) dans l’équipe
🎯 Objectif
Produire un logiciel de très haute qualité, facilement modifiable.
💡 Caractéristiques typiques
Très orientée technique
Exige une forte discipline de développement
Idéale pour projets avec incertitude technique ou risques élevés
////
Lean vient du Toyota Production System, appliqué au logiciel.
🔧 Principes clés
Éliminer les gaspillages (work in progress excessif, tâches inutiles…)
Livrer rapidement la valeur au client
Construire la qualité dès le départ
Optimiser le flux de travail
Amélioration continue (« kaizen »)
Autonomiser les équipes
🎯 Objectif
Réduire les temps de cycle, maximiser la valeur, minimiser la perte.
💡 Caractéristiques typiques
Peu de rituels imposés
Très flexible
Inspiré par la gestion industrielle et l’optimisation de processus
///
Kanban + gitissues + merge etc.
-> exo Kanban/Trello/git issues/attribute, label, merge.
~= 35min.
Git ~= 45min.
- git tags ?