Année Académique 2023-2024

COURS GENIE LOGICIEL

L2

Avril 2024
Enseignant : Dr. KOPOIN N’Diffon Charlemagne

Contacts : 0749950512 / 0153979792

E-mail : [email protected] / [email protected]/

 Génie Logiciel

CHAPITRE 3:
MODELISATION DE
PROCESSUS DE
DEVELOPPEMENT
LOGICIEL

Page 2 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Table des matières
❖ Pré-requis .................................................................................................................................................... 4
❖ Objectifs Généraux ..................................................................................................................................... 4
❖ Objectifs du chapitre .................................................................................................................................. 4
1. Introduction ....................................................................................................................................................... 5
2. Cycle de vie du logiciel et modèle du cycle de vie du logiciel ........................................................................ 5
2.1. Rappel sur le cycle de vie du logiciel..................................................................................................... 5
2.2. Modèles du cycle de vie ......................................................................................................................... 7
2.2.1. Les modèles séquentiels .................................................................................................................... 8
2.2.2. Les modèles itératifs ....................................................................................................................... 11
3. Références....................................................................................................................................................... 15

Page 3 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
 ❖ Pré-requis

➢ Connaissance générale sur les techniques de modélisation

➢ Connaissance générale sur les logiciels

❖ Objectifs Généraux
L’objectif principal de ce cours est d’initier les étudiants, à la conception des applications
informatiques de façon systématique (méthodique) et reproductible (rééditable); en les
incitant à rechercher et établir les fonctionnalités d'une application, et à les modéliser sous
forme de cas d'utilisation et de scénarios ainsi que rechercher les classes et les acteurs
nécessaires à la conception de l'application. Et, d’une manière spécifique ce cours vise à :
➢ Acquérir aux étudiants qui auront suivi ce cours, les bonnes pratiques de conception,
comme l'utilisation de patron de conception (design pattern), le découpage en
couches de l’architecture, la structuration en paquetages et le maquettage ;
➢ Maîtriser des techniques de génie logiciel, en se focalisant sur les approches par
objets et par composants ;
➢ Présenter un aperçu de l'état de l'art en matière de génie logiciel. .
➢ Proposer un ensemble de pratiques pragmatiques qui permettent de survivre à un
projet de développement de logiciel.

❖ Objectifs du chapitre
Ce chapitre aborde la modélisation de processus de développement logiciel.

➢ Maitriser le cycle de vie du développement logiciel ;

➢ Connaitre les modèles de cycle de vie
➢ Connaitre les méthodes agiles
➢ Connaitre les design pattern

Page 4 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
1. Introduction
La modélisation de développement logiciel aide les développeurs à sélectionner la stratégie
pour développer le produit logiciel. Ainsi, chaque modélisation de développement possède ses
outils propres, ses méthodes et ses procédures qui permettent d’exprimer clairement et
définissent le cycle de vie de développement du logiciel.

2. Cycle de vie du logiciel et modèle du cycle de vie

du logiciel
2.1. Rappel sur le cycle de vie du logiciel
Le cycle de vie d'un logiciel (en anglais software lifecycle), désigne toutes les étapes du
développement d'un logiciel, de sa conception à sa disparition. L'objectif d'un tel
découpage est de permettre de définir des jalons intermédiaires permettant la validation du
développement logiciel, c'est-à-dire la conformité du logiciel avec les besoins exprimés, et la
vérification du processus de développement, c'est-à-dire l'adéquation des méthodes mises en
œuvre.
Le cycle de vie du logiciel comprend généralement les activités suivantes :

1. Définition des besoins (Pourquoi?) :

Activités : il faut effectuer des consultations d'experts et d'utilisateurs potentiels et
réaliser des questionnaires d'observation de l'usager dans ses tâches :
• Pourquoi faut-il réaliser un logiciel?
• Y a-t-il de meilleures alternatives?
• Le logiciel sera-t-il satisfaisant pour les utilisateurs?
• Y a-t-il un marché pour le logiciel?
• A-t-on le budget, le personnel, le matériel nécessaire?
Productions :
• Cahier des charges (les « exigences »)
• Fonctionnalités attendues
• Contraintes non fonctionnelles

Page 5 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
 • Qualité, précision, optimalité, ...
• temps de réponse, contraintes de taille, de volume de traitement, …

2. Analyse des besoins / spécification (Quoi?)

Activités : Définir précisément les fonctions que le logiciel doit réaliser ou fournir en
définissant les spécifications générales : Objectifs, contraintes (utilisation de matériels
et outils existants) et généralités à respecter ; les spécifications fonctionnelles :
description détaillée des fonctionnalités du logiciel et les spécifications d'interface :
description des interfaces du logiciel avec le monde extérieure (hommes, autres
logiciels, matériels...).
Productions :
• Dossier d'analyse
• Ébauche du manuel utilisateur
• Première version du glossaire

3. Codage et tests unitaires (Comment ?)

Activités : Définir la structure ou l’architecture du logiciel (décomposition en modules)
et la spécification des interfaces des modules, ensuite réaliser la conception détaillée
du logiciel en implémentant les algorithmes de chacune des procédures des modules et
les tester indépendamment les uns des autres.

Productions :
• Modules codés et testés
• Documentation de chaque module
• Résultats des tests unitaires
• Planning mis à jour

4. Vérification et validation
Activités : Les modules doivent être testés et intégrés suivant un plan d'intégration, de
plus le test de l'ensemble (modules intégrés) doit être réalisé conformément au plan de
tests. Il faut intégrer les différents modules avec validation / vérification de l’adéquation

Page 6 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
 de l’implantation, de la conception et de l’architecture avec le cahier de charge
(acceptation).

Productions :
• Logiciel testé
• Jeu de tests de non-régression
• Manuel d'installation : guide dans les choix d'installation
• Version finale du manuel utilisateur
• Manuel de référence : liste exhaustive de chaque fonctionnalité

5. Maintenance

Activités : Utilisation en situation réelle, retour d’information des usagers, des

administrateurs, des gestionnaires…Il faut organiser une formation de l'utilisateur avec
une assistance technique et effectuer si nécessaire des maintenance correctives en cas
de non conformité aux spécifications, avec détection et correction des erreurs
résiduelles ; maintenance adaptative concernant la modification de l'environnement
(matériel, fournitures logicielles, outil, …) ou maintenance évolutive à cause de
changement des spécifications fonctionnelles du logiciel.

Productions :
• Logiciel corrigé
• Mises à jour, patch
• Documents corrigés.

La séquence et la présence de chacune de ces activités dans le cycle de vie dépend du choix
d'un modèle de cycle de vie entre le client et l'équipe de développement.

2.2. Modèles du cycle de vie

Les modèles du cycle de vie du logiciel sont des « plans de travail » qui permettent de
planifier le développement. Plus le logiciel à développer est complexe (taille, algorithmes) et
critique, plus il est important de bien contrôler le processus de développement et plus les

Page 7 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
documents qui accompagnent le logiciel doivent être précis et détaillés. Les modèles du cycle
de vie sont nombreux et peuvent être classés en trois principales catégories [1] :
- les modèles séquentiels ;
- les modèles itératifs et
- les méthodes agiles

2.2.1. Les modèles séquentiels

Les modèles séquentiels de cycle de vie d'un logiciel décrivent les différentes étapes de
développement d'un logiciel de manière séquentielle :

a. Modèle en cascade
Ce modèle est l'un des plus anciens et des plus simples. Il suit une approche linéaire dans
laquelle les différentes étapes (analyse, conception, développement, test, déploiement) sont
effectuées dans un ordre fixe. Chaque étape doit être achevée avant de passer à la suivante.

Figure 1: Modèle du cycle de vie en cascade

Page 8 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
 Figure 2: Modèle du cycle de vie en cascade avec itérations

L’activité d’une étape se réalise avec les résultats fournis par l’étape précédente ; ainsi, chaque
étape sert de contrôle du travail effectué lors de l’étape précédente et chaque phase ne peut
remettre en cause que la phase précédente ce qui, dans la pratique, s’avère insuffisant.
L’élaboration des spécifications est une phase particulièrement critique : les erreurs de
spécifications sont généralement détectées au moment des tests, voire au moment de la
livraison du logiciel à l’utilisateur. Leur correction nécessite alors de reprendre toutes les
phases du processus. Ce modèle est mieux adapté aux petits projets ou à ceux dont les
spécifications sont bien connues et fixes.

b. Modèle en V
Ce modèle est similaire au modèle en cascade, mais il met davantage l'accent sur les tests.
Chaque phase de développement est associée à une phase de test correspondante.

Figure 3: Modèle du cycle de vie en V

Page 9 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Le modèle en V du cycle de vie du logiciel précise la conception des tests : (les tests système
sont préparés à partir de la spécification ; les tests d’intégration sont préparés à partir de la
conception architecturale ; les tests unitaires sont préparés à partir de la conception détaillée
des composants). Dérivé du modèle de la cascade, le modèle en V du cycle de développement
montre non seulement l’enchaînement des phases successives, mais aussi les relations logiques
entre phases plus éloignées.

Ce modèle fait apparaître le fait que le début du processus de développement conditionne ses
dernières étapes. L’avantage d’un tel modèle est d’éviter d’énoncer une propriété qu’il est
impossible de vérifier objectivement une fois le logiciel réalisé. Le cycle en V est le cycle qui
a été normalisé, il est souvent adapté aux projets de taille et de complexité moyenne. Il est
largement utilisé, notamment en informatique industrielle et en télécommunication. Ce modèle
fait également apparaitre les documents qui sont produits à chaque étape, et les «revues» qui
permettent de valider les différents produits.

Page 10 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
2.2.2. Les modèles itératifs
Les modèles itératifs sont des modèles de développement de logiciel qui impliquent des cycles
de développement répétitifs et incrémentaux pour produire des versions fonctionnelles d'un
produit logiciel. Ils sont souvent utilisés dans les projets de développement de logiciels où les
exigences peuvent changer ou évoluer au fil du temps.

a. Le modèle en spirale de Boehm

Le modèle en spirale de Boehm est un modèle itératif de développement de logiciel qui
implique la planification, la conception, la mise en œuvre et l'évaluation à chaque étape. Il suit
un processus cyclique où chaque cycle se compose de quatre phases : la planification, la
définition des objectifs, l'évaluation des risques, et la mise en œuvre. Chaque cycle de
développement est basé sur les résultats du cycle précédent.

Figure 4: Modèle du cycle de vie en spirale

Ce modèle s’inscrit dans une relation contractuelle entre le client et le fournisseur. De ce fait
les engagements et validations présentent un caractère formalisé. Chaque cycle donne lieu à
une contractualisation préalable, s’appuyant sur les besoins exprimés lors du cycle précédent.

Page 11 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Le modèle du cycle de vie en spirale est un modèle itératif (répété), où la planification de la
version se fait selon une analyse de risques. L’idée est de s’attaquer aux risques les plus
importants assez tôt, afin que ceux-ci diminuent rapidement. De façon générale, les risques liés
au développement de logiciels peuvent être répartis en quatre catégories :
• les risques commerciaux (placement du produit sur le marché, concurrence);
• les risques financiers (capacités financières suffisantes pour réaliser le
produit);
• les risques techniques (la technologie employée est-elle ´éprouvée ?) ;
• les risques de développement (‘équipe est-elle suffisamment expérimentée ?).

b. le modèle incrémental
Le modèle incrémental est un modèle de développement de logiciel dans lequel les exigences
sont divisées en plusieurs étapes, et chaque étape est développée et testée séparément. Il suit
un processus linéaire séquentiel, mais chaque étape est une amélioration incrémentale par
rapport à la précédente.
Dans le modèle incrémental, seul un sous ensemble est développé à la fois. Dans un premier
temps un logiciel noyau est développé, puis successivement, les incréments sont développés et
intégrés. Chaque incrément est développé selon l’un des modèles précédents. Dans ce modèle,
les intégrations sont progressives et il peut y avoir des livraisons et des mises en service après
chaque intégration d’incrément. Le modèle incrémental présente comme avantages :
• chaque développement est moins complexe ;
• les intégrations sont progressives ;
• possibilité de livraisons et de mises en service après chaque incrément ;
• meilleur lissage du temps et de l’effort de développement à cause de la
possibilité de recouvrement des différentes phases. L’effort est constant dans
le temps par opposition au pic pour spécifications détaillées pour les modèles
en cascade ou en V.
Le modèle incrémental présente comme Risques :
• la remise en cause du noyau de départ ;
• la remise en cause des incréments1 précédents;
• ou encore l’impossibilité d’intégrer un nouvel incrément

1
Un incrément du logiciel est un sous-ensemble du logiciel complet, qui consiste en un petit
nombre de fonctionnalités.
Page 12 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
 c. Modèle par prototypage
Un modèle de processus basé sur le prototypage se révèle alors plus approprié que le modèle
classique de la cascade. Le prototypage permet de contourner la difficulté de la validation liée
à l’imprécision des besoins et caractéristiques du système à développer. Cela veut dire que
lorsqu’il est difficile d’établir une spécification détaillée, on a recours au prototypage qui est
considéré, dans ce cas, comme un modèle de développement de logiciels.
Il s’agit d’écrire une première spécification et de réaliser un sous-ensemble du produit logiciel
final. Ce sous ensemble est alors raffiné incrémentalement et évalué jusqu’à obtenir le produit
final. On en distinguera deux types de prototypage :

- Le prototypage Jetable : ici, le squelette du logiciel n’est créé que dans un but et dans
une phase particulière du développement.
- Le prototypage Evolutif : ici, on conserve tout, au long du cycle de développement. Il
est amélioré et complété pour obtenir le logiciel final

Figure 5: Modèle du cycle de vie par prototypage

Page 13 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
2.2.3. Les méthodes agiles
Les méthodes agiles mettent l'accent sur la collaboration, l'adaptabilité et la livraison de
fonctionnalités en continu plutôt que sur la planification rigide et la documentation exhaustive.
Il existe plusieurs modèles, notamment :

??

Page 14 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
3. Références
[1] L. DJAKHDJAKHA, « Génie Logiciel », 2023, Consulté le: 2 avril 2024. [En ligne].
Disponible sur: https://dspace.univ-
guelma.dz/jspui/bitstream/123456789/14843/1/polycopie%20de%20cours%20genie%20l
ogiciel%20%20Djakhdjakha%20lynda.pdf

Page 15 sur 15
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC