TITRE DE L’UE : Système d’Exploitation I

Nombre de crédits : 02 Crédits Volume Hor

YOSSA NGUEKAM Christian, Ingénieur de Conception

Diplômé de la 1ère Promotion de l’ENSPM-Cameroun
 TABLE DES MATIERES
INTRODUCTION......................................................................................................................2
PREMIER CHAPITRE – LES TYPES ET CARACTERISTIQUES DES SYSTEMES
D’EXPLOITATION...................................................................................................................2
I.1. RAPPELS.........................................................................................................................2
I.2. DEFINITION....................................................................................................................3
I.3. ROLES..............................................................................................................................3
I.4. SYSTEME MULTI UTILISATEUR................................................................................4
I.5. SYSTEME MULTI TACHE............................................................................................5
I.6. QUELQUES FAMILLES DE SE.....................................................................................5
DEUXIEME CHAPITRE – COOPERATION ET COMPETITION ENTRE PROCESSUS....7
II.1. RESSOURCES PARTAGEES........................................................................................7
II.2. RESSOURCES CRITIQUES..........................................................................................7
II.3. EXECUTION SEQUENTIELLE ET EXECUTION PARALLELE..............................8
II.4. BLOCAGE ET INTER BLOCAGE................................................................................8
II.5. SYNCHRONISATION, SECTION CRITIQUE, OUTILS DE SYNCHRONISATION
.................................................................................................................................................8
II.6 ORGANISATION INTERNE DES SE............................................................................8
II.7 REPRESENTATION INTERNE DU NOYAU.............................................................10
II.8 OPERATIONS SUR LES FICHIERS............................................................................11
II.9 METHODES D’ACCES................................................................................................11
II.10 GESTION D’ESPACE DISQUE.................................................................................11
TROISIEME CHAPITRE – ADMINISTRATION DES SYSTEMES INFORMATIQUES. .12
III.1. CONFIGURATION D’UN SYSTEME ;.....................................................................12
III.2. ÉVALUATION DU FONCTIONNEMENT ;.............................................................13
III.3. PROTECTION.............................................................................................................13
II.4. SECURITE....................................................................................................................15
III.5. CLASSIFICATION DES SYSTEMES.......................................................................17
CONCLUSION.........................................................................................................................20
BIBLIOGRAPHIE....................................................................................................................21
 INTRODUCTION
L’étude des SE permet d’accéder à des formations avancées (Systèmes distribués,
virtualisation, cloud computing, Big Data …).
Les systèmes d’exploitation (SE) au quotidien:
• Machines à laver, consoles de jeux, Smartphones, ordinateurs, SmartTV…
• «Le système démarre», «Le système a planté» , « version 3.0.1 du système », « bug système »,
Académique/Professionnel:
• Génie Logiciel: le logiciel s’appuie sur un SE
• Administration réseau: Les machines des réseaux (PCs, routeurs, serveurs, …) possèdent des
SE!
Mais encore: Les SE ont été particulièrement importants dans le développement de
l’informatique, à côté de l’évolution technologique des ressources matérielles.

PREMIER CHAPITRE – LES TYPES ET

CARACTERISTIQUES DES SYSTEMES D’EXPLOITATION
Un ordinateur se compose d’éléments matériels « Hardware » et d’éléments logiciels «
Software ».Cependant, comment coexistent-ils? Quel est le rôle joué par le SE? Comment
réalise-t-il ce rôle?Un SE est fortement lié aux ressources matérielles sur lesquelles il s’exécute.
Il exploite l’ensemble des instructions exécutables par l’ordinateur (càd le matériel) et gère ses
ressources.

I.1. RAPPELS
Le Processeur ou L’Unité Centrale de Traitement (UCT) ou Central Processing Unit (CPU),
est « le cerveau » de l’ordinateur qui interprète et exécute les instructions du programme situées
en mémoire centrale. L’UCT est composée de l’Unité arithmétique et logique (UAL) et de
l’Unité de commande (ou de contrôle).L’UAL effectue les opérations arithmétiques et logiques.
L’Unité de commande dirige le fonctionnement de toutes les autres unités: UAL, mémoire,
entrées / sorties, etc., en leur fournissant les signaux de cadence (l’horloge) et de commande.
La Mémoire est constituée des registres (type de mémoire qui sert à stocker des données à
traiter, des résultats intermédiaires ou des informations de commande. Le temps d’accès est
minimal, très petit espace de stockage et à prix élever), de la mémoire cache (Un bloc de cette
mémoire est appelé ligne de cache qui est composée de plusieurs mots mémoire consécutifs en
mémoire. Le processeur essaie d’accéder à un mot d’abord dans la cache, avant de passer
à la mémoire principale: En cas d’échec (miss), le mot est gardé dans la cache pour un accès
futur. En cas de succès (hit), la mémoire principale n’est pas accédée. Cette mémoire est très
rapide, de petite taille) et la mémoire vive (RAM (Random Access Memory), on peut accéder
instantanément à n’importe quelle espace mémoire. Volatile et contient les données et les
instructions des applications en cours. Mémoire rapide, de taille plus importante et à prix moyen.
Le disque : sert principalement à stocker les données d’une manière non-volatile. L’accès est
mécanique, introduisant un délai important en lecture/écriture relativement à la RAM. Sert
éventuellement à « étendre » la RAM. Un espace plus important et à coût bas (selon les
technologies).
La mémoire morte: ROM (Read Only Memory) mémoire en lecture seule. Permanente,
contenant des microprogrammes enregistrés à l’usine sur des puces électroniques de la carte
mère, contenant les routines de démarrage de l’ordinateur. C’est une mémoire non volatile,
rapide et à bas coût.
Les périphériques d’entrée/sortie (E/S): Permettent le dialogue (échange d’informations)
avec ce qui se trouve à l’extérieur de la machine. Ils se composent généralement de deux parties:
Le matériel (physique).Le contrôleur: une puce ou un ensemble de puces qui contrôle
physiquement le périphérique. Présente au système d'exploitation une interface « simple »,
nommée Driver, pour recevoir les commandes et retourner leurs résultats.

I.2. DEFINITION
Un système d’exploitation est une couche logicielle indispensable pour exploiter, d’une
manière simple, les ressources matérielles d’un ordinateur.
Il existe en général deux modes de fonctionnement :
 le mode noyau (mode superviseur, privilégié): dispose d'un accès complet à tout le
matériel et peut exécuter toutes les instructions que la machine est capable
d'exécuter.
 le mode utilisateur: le reste du système s'exécute en mode utilisateur, dans lequel seul
un sous-ensemble des instructions de la machine est exécutable.
Le programme d'interface utilisateur: le Shell ou l'interface graphique, est le niveau le plus
bas du logiciel en mode utilisateur, et permet à l'utilisateur de démarrer d'autres programmes,
comme un navigateur Web, un lecteur de courrier électronique ou un lecteur de musique…

I.3. ROLES
C’est un ensemble de programmes de gestion du système qui permettent de gérer les
éléments fondamentaux de l'ordinateur: le matériel, les logiciels, la mémoire les données, les
réseaux. Ainsi il :
  Cache la complexité du hardware, que ce soit pour les applications ou pour les
développeurs : diverses technologies de stockage, de transmission, … .
 Gère les ressources: allocation de mémoire, ordre d’exécution.
 Isolation et protection: des programmes, des utilisateurs, …
 Simplifier l’interaction avec le matériel puis contrôler et gérer son utilisation.
 La gestion des processus: un processus est un programme en cours d’exécution. Le
SE doit gérer l'allocation de ressources aux processus en proposant à chacun un environnement
dans lequel il peut s'exécuter en toute sécurité.
 La gestion de la mémoire : Le SE doit gérer l'allocation de mémoire aux processus et
contrôler physiquement les emplacements auxquels peut accéder un processus.
 La gestion des périphériques: Le SE doit gérer les périphériques afin de leur
permettre d’être partagés de manière efficace entre les processus.
 La gestion du système de fichiers : Le SE doit gérer des structures de données
permettant de créer, stocker, supprimer, lire (etc. …) les informations et de les organiser dans des
fichiers sur des mémoires secondaires (disque dur, CD-ROM, clé USB, disques SSD, etc.).
 La protection: l'accès aux données doit être réglementé puisqu’il existe plusieurs
utilisateurs et processus. Le SE doit garantir que les fichiers, les segments de mémoire, etc … ne
peuvent être utilisés que par les processus ayant obtenu l'autorisation appropriée.
 La sécurité: Le SE doit posséder des mécanismes pour se défendre contre les attaques
externes et internes. Elles comprennent les virus, des attaques de déni de service (Denial of
Service: DoS).

I.4. SYSTEME MULTI UTILISATEUR

Ils sont capables d'exécuter de façon concurrente et indépendante des applications appartenant
à plusieurs utilisateurs. Concurrente?: les applications sont actives au même moment et se
disputent l'accès aux différentes ressources. Indépendante?: chaque application peut réaliser son
travail sans se préoccuper de ce que font les applications des autres utilisateurs. Ce contexte fait
appel aux notions suivantes:
 Utilisateurs: matérialisé par un espace privé de travail sur la machine. Chaque
utilisateur est identifié par un numéro unique, appelé l'identifiant de l'utilisateur, ou UID (pour
l'anglais User IDentifier).
 Groupe d'utilisateurs: permet de partager de façon sélective le matériel avec
d'autres utilisateurs. Un groupe est également identifié par un numéro unique dénommé
identifiant de groupe, ou GID (pour l'anglais Group IDentifier).
  Super-utilisateur: ou encore superviseur (root en anglais), un utilisateur particulier
qui peut pratiquement tout faire dans la mesure où le SE ne lui applique jamais les mécanismes
de protection. Il peut, en particulier, accéder à tous les fichiers du système et interférer sur
l'activité de n'importe quel processus en cours d'exécution.

I.5. SYSTEME MULTI TACHE

Appelés aussi multiprogrammés, ils permettent l'exécution de plusieurs tâches à la fois :
exécuter un programme utilisateur, lire les données d'un disque, afficher des résultats sur un
terminal. Ce contexte fait appel aux notions suivantes:
 Processus (et non programme) : un processus est une instance de programme en
exécution. Le processus est représenté par un programme(le code), ses données et son état
d’avancement communément appelés variables d’environnement.
 Temps partagé : le micro-processeur à un instant donné, n'exécute réellement qu'un
seul processus. Faire passer le processeur d'un processus à un autre, en exécutant chaque
programme pendant quelques dizaines de millisecondes, donne l’impression que tout s’exécute
en même temps : c’est Le pseudo-parallélisme.
 Espace mémoire d'un processus: chaque processus possède son propre espace
mémoire, non accessible aux autres processus. On parle de l'espace d'adressage du processus.

I.6. QUELQUES FAMILLES DE SE

L’existence des SE depuis fort longtemps ainsi que leur utilisation dans différents domaines
technologiques ont permis l’émergence de plusieurs familles de SE.
 Mainframes*: sont Ordinateurs de taille d’une pièce qu’on trouve dans les centres de
données d'entreprise ayant de grandes capacités de l’ordre de 1000 disques et des millions de
giga-octets de données. Les SE sont amenés à traiter plusieurs tâches à la fois, dont la plupart
nécessitent des quantités importantes d'E/S.
 Serveurs: sont des PC à ressources importantes ou des workstations ou des
Mainframes. Les SE doivent être capables de gérer plusieurs utilisateurs à la fois sur un réseau et
de partager des ressources matérielles et logicielles.
 Multiprocesseurs: Un moyen pour obtenir une puissance de calcul majeure est de
connecter plusieurs CPU dans un seul système. Ces systèmes ont besoin de SE assez spéciaux,
des variations de SE pour serveurs.
 Personal Computer : Les SE pour PC modernes supportent la multiprogrammation,
pour fournir un bon support à un seul utilisateur.
  Handheld : Connu auparavant sous le nom de PDA (Personal Digital Assistant),
ancêtre des smartphones et des tablettes. La plupart de ces appareils possèdent des CPU
multicoeurs, GPS, caméras, capteurs…Ils ont des exigences particulières ce qui nécessite des SE
sophistiqués et bien
adaptés.
 Les systèmes embarqués : S'exécutent sur des circuits pour des périphériques
n’acceptant pas de futures installations de logiciels par l’utilisateur (Ex: fours à micro-ondes, les
téléviseurs, les voitures, etc.): tout est en ROM. Ces SE n’ont pas besoin de considérer l’aspect
de protection contre les logiciels malveillants, ce qui entraîne une simplification de la
conception.
 Nœud capteur*: Unités qui composent un réseau de capteurs sans fil. Chaque nœud
est composé de CPU, RAM, ROM, capteurs (température, humidité, lumière, mouvement …):
un vrai ordinateur. Le SE doit être petit et simple car les nœuds ont peu de RAM et sont
contraints
en énergie.
 Systèmes temps réel*: Se caractérisent par le temps (ou le délai) comme contrainte.
Si le système doit fournir des garanties absolues qu'une certaine action se produira à un certain
moment (ou dans un certain intervalle temps), on parle d’un système en temps réel strict (Hard
real-time).Si le système doit fournir des garanties avec une certaine probabilité et ainsi un
délai plus grand mais acceptable, on parle de temps réel souple (Soft real-time).
DEUXIEME CHAPITRE – GESTION DES PROCESSUS
 II.1. DEFINITIONS

DEUXIEME CHAPITRE – COOPERATION ET

COMPETITION ENTRE PROCESSUS
Un processus est Une tâche fondamentale des SE est d’assurer l’exécution de divers
programmes. C’est aussi un programme est une entité statique stockée dans le disque. Une fois
chargé en mémoire pour s’exécuter, le programme devient un processus, qui est une entité
active.« Un processus peut être définit comme étant une instance de programme en cours
d'exécution ». L’exécution d’un processus est en général une alternance de calculs effectués par
l’UCT et de requêtes d'E/S effectuées par les périphériques. Un processus va concourir avec
d’autres processus pour l’obtention d’une ressource (UCT, périphérique E/S,...).La gestion
d’accès aux ressources est dirigée par la partie du SE appelée ordonnanceur.
Un processus est composé principalement:
Du code du programme (aussi appelé section texte du processus).
Du contenu des registres de l’UCT et de la valeur du compteur de programme (activité courante
du processus).
De la pile du processus (stack), contenant les données temporaires (paramètres des fonctions,
variables locales,…).De la section données (data), contenant les variables globales du
programme. D’un tas (heap), qui est une mémoire dynamiquement allouée pendant l’exécution
du processus (pour lecture de fichiers, …)
• Si un même programme est exécuté plusieurs fois, il correspond à plusieurs processus.
•Un processus peut communiquer des informations avec d’autres processus.

II.1. RESSOURCES PARTAGEES

II.2. RESSOURCES CRITIQUES

Le développement de logiciel impose d’effectuer un certain nombre d’étapes. Il existe de
nombreux modèles de cycle de vie du développement d’un logiciel, les plus courants comportent
les phases suivantes :
 II.3. EXECUTION SEQUENTIELLE ET EXECUTION
PARALLELE

II.4. BLOCAGE ET INTER BLOCAGE

II.5. SYNCHRONISATION, SECTION CRITIQUE, OUTILS

DE SYNCHRONISATION

II.6 ORGANISATION INTERNE DES SE

 Monolithique (d'un seul bloc) :
o L'ensemble du SE s'exécute en un seul programme en mode noyau.
o Le SE est écrit comme une collection de procédures, reliées entre elles dans un seul
programme binaire exécutable unique.
  Implémentation simple.
↓ Difficile à maintenir!
o MS-DOS est un exemple d'un tel système.
 Systèmes à modes noyau et utilisateur:
o Le SE démarre en mode noyau, ce qui permet d'initialiser les périphériques et de mettre
en place des routines de service, et commute ensuite en mode utilisateur.
o En mode utilisateur, on utilise les appels système pour avoir accès à ce qui a été prévu
par le système.
o Unix et Windows (tout au moins depuis Windows 95) sont de tels systèmes.
 Systèmes à modes noyau et utilisateur: Appel système

1) Le noyau reçoit l’appel système,

2) Vérifie qu'il s'agit d'une demande valable (en particulier du point de vue des droits d'accès),
3) Exécute,
4) Renvoie au mode utilisateur.
 Systèmes en couches (généralisation):
o Chaque couche réalise sa fonction en s'appuyant exclusivement sur l’ensemble des
fonctions de la couche qui lui est immédiatement inférieure.
o Une couche typique du SE consiste en des structures de données et un ensemble de
routines pouvant être invoquées par des couches de niveau supérieur.
 Vérification et débogage relativement simples.
↓ Difficulté lors de la définition des couches; tendance à être moins efficaces.
 Systèmes à micro Kernel:
o Un noyau minimal (appelé micronoyau) de taille de code réduite.
 o Se contente en général de gestionnaires de tâche et de mémoire simples, et un
mécanisme de communication entre processus.
o Les gestionnaires de périphériques, les gestionnaires d'appels système, etc… sont
implémentés en tant que programmes système et utilisateurs.
 Un SE plus simple à étendre.
↓ Un Problèmes de performance.

II.7 REPRESENTATION INTERNE DU NOYAU

Le noyau (kernel en anglais) comporte un certain nombre des plus importantes routines
(sous-programmes) du SE. Il est chargé en mémoire vive à l'initialisation du système. Les
autres routines, moins critiques, sont appelées des utilitaires. Le noyau d'un système
d'exploitation se compose de quatre parties principales : le gestionnaire de tâches (ou des
processus), le gestionnaire de mémoire, le gestionnaire de fichiers et le gestionnaire de
périphériques d'entrée-sortie. Il possède également deux parties auxiliaires : le chargeur du
système d'exploitation et l'interpréteur de commandes.
o Le chargeur du système d'exploitation: appelé, pour PC et MAC, BIOS (pour Basic
Input Output System) et est chargé à une adresse bien déterminée en mémoire RAM. Ce
logiciel initialise les périphériques, charge un secteur du disque, et exécute ce qui y
est placé.
o L'interpréteur de commandes (Shell en anglais): est souvent considéré comme une partie
du SE et exécute une boucle infinie qui affiche une invite (montrant par-là que l'on attend
quelque chose), lit le nom du programme et les paramètres saisis par l'utilisateur à ce moment-
là
et l'exécute.
o Gestionnaire de tâches (ordonnanceur) : divise le temps en laps de temps (en anglais
slices, tranches) et décide périodiquement d'interrompre le processus en cours et de démarrer
(ou
reprendre) l'exécution d'un autre.
o Gestionnaire de mémoire: connaître les parties libres et les parties occupées de la
mémoire, allouer de la mémoire aux processus qui en ont besoin, récupérer la mémoire utilisée
par un processus lorsque celui-ci se termine, traiter le va-et-vient entre le disque et la mémoire
principale lorsque cette dernière doit être étendue.
o Gestionnaire de fichiers: faire abstraction des spécificités des disques et des autres
périphériques d'entrée-sortie, offrir au programmeur un modèle agréable et facile d'emploi.
 o Gestionnaire de périphériques: envoyer les commandes aux périphériques, intercepter
les interruptions, traiter les erreurs.

II.8 OPERATIONS SUR LES FICHIERS

II.9 METHODES D’ACCES
II.10 GESTION D’ESPACE DISQUE
 TROISIEME CHAPITRE – ADMINISTRATION DES
SYSTEMES INFORMATIQUES
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.
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
documents qui accompagnent le logiciel doivent être précis et détaillés.
Il s’avère de nos jours, que nous ne pouvons plus avoir une démarche unique dans le
développement de projets informatiques, mais qu’il faut construire le découpage temporel en
fonction des caractéristiques de l’entreprise et du projet. On s’appuie pour cela sur des
découpages temporels génériques, appelés modèles de développement (process model) ou
modèles de cycle de vie d’un projet informatique. Les principaux modèles sont :
 le modèle du code-and-fix ;
 le modèle de la transformation automatique ;
 le modèle de la cascade ;
 le modèle en V ;
 le modèle par incrément ;
 le modèle par prototypage ;
 le modèle de la spirale.
III.1. CONFIGURATION D’UN SYSTEME ;
C’est un modèle qui repose sur la possibilité d’une détermination facile des besoins :
une première phase de Compréhension du problème est suivie d’une phase de Programmation ;
puis une phase de Mise au point, parfois en collaboration avec l'utilisateur du futur système, est
répétée jusqu’à l’atteinte du résultat visé.
 Le modèle du code-and-fix.

III.2. ÉVALUATION DU FONCTIONNEMENT ;

C’est un modèle basé sur la possibilité de transformer automatiquement des spécifications
en programmes. L’essentiel de l’effort va donc porter sur une description exhaustive des
spécifications qui devront être complètement validées. Une succession de cycles Phase de
Spécifications – Phase de Validation s’achève par la phase de Transformation, où s’effectue la
génération du code.

Le modèle de la transformation automatique

III.3. PROTECTION
C’est un modèle qui a comme objectif majeur de jalonner (présenter sobrement)
rigoureusement le processus de développement et de définir de façon précise les rôles respectifs
du fournisseur qui produit un livrable et du client qui accepte ou refuse le résultat. Le découpage
temporel se présente comme une succession de phases affinant celles du découpage classique :
Étude de faisabilité, Définition des besoins, Conception générale, Conception détaillée,
Programmation, Intégration, Mise en œuvre. Chaque phase donne lieu à une validation officielle.
Si le résultat du contrôle n’est pas satisfaisant, on modifie le livrable. En revanche, il n’y a pas de
retour possible sur les options validées à l’issue de phases antérieures.
 Le cycle de vie dit de la « cascade » date de 1970, il est l’œuvre de Royce. Ce Cycle de
vie est linéaire (présentoir) sans aucune évaluation entre le début du projet et la validation. Ici,
Le projet est découpé en phases successives dans le temps et à chaque phase correspond une
activité principale bien précise produisant un certain nombre de livrables et On ne passe à l’étape
suivante que si les résultats de l’étape précédente sont jugés satisfaisants.
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. Dans le modèle en cascade, on effectue les différentes étapes du logiciel de
façon séquentielle. Les interactions ont lieu uniquement entre étapes successives : on s’autorise
des retours en arrière uniquement sur l’´étape précédente. Par exemple, un test ne doit pas
remettre en cause la conception architecturale.

Modèle du cycle de vie en cascade N° 1

 Modèle du cycle de vie en cascade N°2
Lorsque qu’un test remet en cause la conception détaillé ou architecturale ou, pire, les
spécifications ou la définition des besoins, le modèle devient incontrôlable

Modèle du cycle de vie en cascade Incontrôlable

II.4. SECURITE
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. Le modèle du cycle de vie en V est souvent
adapté aux projets de taille et de complexité moyenne.
 La première branche correspond à un modèle en cascade classique. Toute description
d’un composant est accompagnée de définitions de tests. Avec les jeux de tests préparés dans la
première branche, les étapes de la deuxième branche peuvent être mieux préparées et planifiées.
La seconde branche correspond à des tests effectifs effectués sur des composants réalisés.
L’intégration est ensuite réalisée jusqu’à l’obtention du système logiciel final. 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 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.
 Modèle du cycle de vie en « V » N° 2
III.5. CLASSIFICATION DES SYSTEMES

Ce modèle repose sur le même principe que le modèle évolutif, mais il 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. Un cycle comporte six
phases :
 Analyse du risque ;
 Développement d'un prototype (modèle, archétype…) ;
 Simulation et essais du prototype ;
 Détermination des besoins à partir des résultats des essais ;
 Validation des besoins par un comité de pilotage ;
 Planification du cycle suivant.

Le modèle en spirale
Le dernier cycle permet de développer la version finale et d'implémenter le logiciel. Pour
corriger les travers de la démarche linéaire (en Cascade) sont apparus des modèles dits en
spirales, proposé par B. Boehm en 1988, où les risques, quels qu’ils soient, sont constamment
traités au travers de bouclages successifs :
 chaque spire confirme et affine les spires précédentes en menant des activités de même
nature successivement ;
 L’analyse ou la conception ne sont plus effectuées dans une seule phase ou étape mais sont
conduites en tant qu’activités qui se déroulent sur de multiples phases ;
 A chaque étape, après avoir défini les objectifs et les alternatives, celles-ci sont évaluées
par différentes techniques (prototypage, simulation, ...), l’étape est réalisée et la suite est
planifiée.
 Le nombre de cycles est variable selon que le développement est classique ou incrémental ;
 Ce modèle met l’accent sur l’analyse des risques tels que les exigences démesurées par
rapport à la technologie, la réutilisation de composants, calendriers et budgets irréalistes,
la défaillance du personnel, etc.
 Ce modèle est utilisé pour des projets dont les enjeux (risques) sont importants
Chaque cycle de la spirale se déroule en quatre phases :
 Un cycle de la spirale commence par l’élaboration d’objectifs tels que la performance, la
fonctionnalité, etc. on énumère ensuite les différentes manières de parvenir à ces objectifs,
ainsi que les contraintes. On évalue ensuite chaque alternative en fonction de l’objectif.
 L’étape suivante consiste à évaluer les risques pour chaque activité, comme l’analyse
détaillée, le prototypage, la simulation, etc.
 Après avoir évalué le risque, on choisit un modèle de développement pour le système. Par
exemple, si les principaux risques concernent l’interface utilisateur, le prototypage
évolutif pourrait s’avérer un modèle de développement approprié. Le modèle de la
cascade peut être le plus approprié si le principal risque identifié concerne l’intégration
des sous-systèmes. Il n’est pas nécessaire d’adopter un seul modèle à chaque cycle de la
spirale ou même pour l’ensemble d’un système. Le modèle de la spirale englobe tous les
autres modèles.
 La situation est ensuite réévaluée pour déterminer si un développement supplémentaire est
nécessaire, auquel cas il faudrait planifier la prochaine étape. (on estime au cours d’une
procédure de revue, si on doit passer au prochain cycle de la spirale ou non).
Les principaux risques et leurs remèdes, tels que définis par Boehm, sont les suivants :
 La défaillance de personnel : embauche de haut niveau, formation mutuelle, leaders,
adéquation profil/fonction, ...
 Le calendrier et budgets irréalistes : estimation détaillée, développement incrémental,
réutilisation, élagage des besoins, ...
 Le développement de fonctions inappropriées : revues d’utilisateurs, manuel d’utilisation
précoce,...
 Le développement d’interfaces utilisateurs inappropriées : maquettage, analyse des tâches,
 Le produit « plaqué or » : analyse des coûts/bénéfices, conception tenant compte des coûts,
 La volatilité des besoins : développement incrémental de la partie la plus stable d’abord,
masquage d’information, ...
 Les problèmes de performances : simulations, modélisations, essais et mesures, maquettage,
 les exigences démesurées par rapport à la technologie : analyses techniques de faisabilité,
maquettage,...
 les tâches ou composants externes défaillants : audit des sous-traitants, contrats, revues,
analyse de compatibilité, essais et mesures, ...
Il n’est pas nécessaire d’adopter un seul modèle à chaque cycle de la spirale ou même
pour l’ensemble d’un système. Le modèle de la spirale englobe tous les autres modèles. Le
prototypage peut être utilisé dans une spirale pour résoudre le problème de la spécification des
besoins, puis il peut être suivi d’un développement basé sur le modèle conventionnel de la
cascade. On peut utiliser la transformation formelle pour une partie du système à haute sécurité,
et une approche basée sur la réutilisation pour l’interface utilisateur.
Le modèle du cycle de vie en spiral 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 (l’équipe est-elle suffisamment expérimentée ?).

Modèle du cycle de vie en spirale

 Supposons qu’une équipe doive développer un logiciel comportant une interface
graphique. Un exemple de risque pourrait être un manque de compétence de l’équipe de
développement dans l’écriture d’interfaces. Dans ce cas, il faut tenir compte d’un temps de
formation, et d’un retard possible dans le développement de l’interface. Dans processus de
développement en spiral, on s’attaque au développement de l’interface assez tôt, afin de détecter
le plus rapidement possible les problèmes ´éventuels, et d’avoir le temps d’y remédier.
Dans un cycle de vie en cascade, les activités qui comportent le plus de risques ont lieu à
la fin, lors de la mise en œuvre et de la validation. En s’attaquant d`es le début aux activités les
plus risquées, le modèle en spirale permet d’accélérer la réduction du risque au cours du
développement du logiciel : les risques sont importants lors des premières itérations, et
diminuent lors des dernières itérations.

CONCLUSION
Le génie logiciel est la science des bonnes pratiques de développement de logiciel. Cette
science étudie en particulier la répartition des phases dans le temps, les bonnes pratiques
concernant les documents clés que sont le cahier des charges, le diagramme d'architecture ou le
diagramme de classes. Le but recherché est d'obtenir des logiciels de grande ampleur qui soient
fiables, de qualité, et correspondent aux attentes de l'usager.
Par contre, Le développement de logiciel consiste à étudier, concevoir, construire,
transformer, mettre au point, maintenir et améliorer des logiciels. Ce travail est effectué par les
employés d'éditeurs de logiciels, de sociétés de services et d'ingénierie informatique (SSII), des
travailleurs indépendants (freelance) et des membres de la communauté du logiciel libre. Le
développement d’une application exige de :
 Procéder par étapes, en prenant connaissance des besoins de l’utilisateur ; effectuer
l’analyse ; trouver une solution informatique ; réaliser ; tester ; installer et assurer le suivi.
 Procéder avec méthode, en partant du général aux détails et aux techniques ; fournir une
documentation ; s’aider de méthodes appropriées ; et Savoir se remettre en question.
 Choisir une bonne équipe, en trouvant les compétences adéquates ; définir les missions de
chacun et coordonner les différentes actions pour la construction du logiciel.
 Contrôler les coûts et délais, en considérant l’aspect économique ; maîtriser de la
conduite du projet ; et investissements aux bons moments.
 Garantir le succès du logiciel, en répondant à la demande et assurer la qualité du logiciel.
 Envisager l’évolution du logiciel, du matériel et de l’équipe.
Ainsi, Un logiciel est créé petit à petit par une équipe d'ingénieurs conformément à un cahier
des charges établi par un client demandeur ou une équipe interne. Le logiciel est décomposé en
différents modules et un chef de projet, ou architecte, se charge de la cohérence de l'ensemble.
Différentes activités permettent de prendre connaissance des attentes de l'usager, créer un
modèle théorique du logiciel, qui servira de plan de construction, puis construire le logiciel,
contrôler son bon fonctionnement et son adéquation au besoin. La planification et la répartition
des travaux permettent d'anticiper le délai et le coût de fabrication.
Le logiciel est accompagné d'une procédure d'installation, d'une procédure de vérification de
bonne installation, de documentation (parfois créé automatiquement à partir de commentaires
placés à cet effet dans le code source) et d'une équipe d'assistance au déploiement et à la
maintenance, désignée sous le nom de support. Outre les travaux d'analyse, de conception, de
construction et de tests, une procédure de recette, permettra de déterminer si le logiciel peut
être considéré comme utilisable.
Nous espérons que le support de cours de l’introduction au Génie logiciel, vous a été utile et
vous permettra d’approfondir vos connaissances informatiques relatives à la conception et à la
production des logiciels. L’auteur de cet ouvrage, vous remercie prestement du temps que vous
consacrerez à l’exploitation de support de cours. N’hésitez pas à nous contacter pour plus
d’information. Bonne lecture et digestion.

BIBLIOGRAPHIE
Les documents qui nous ont été utiles pour la réalisation de ce travail sont les suivants :
[1] ACSIOME, Modélisation dans la conception des systèmes d'information, Masson, 1989
[2] Bertrand Meyer, Conception et programmation orientées objet, Editions Eyrolles, 2000
[3] Boehm, B. W., Software engineering economics, Prentice-Hall, 1981, 0-13-822122-7
[4] Booch, Grady, Object-Oriented Analysis and Design, with applications, 3rd Ed. Addison-
Wesley,2007
[5] C. TESSIER, La pratique des méthodes en informatique de gestion, Les Editions
d'Organisation,1995
[6] GALACSI, Comprendre les systèmes d'information : exercices corrigés d'analyse et de
conception,Dunod,1985
[7] I. SOMERVILLE et Franck VALLEE, Software Engineering , 6th Edition, Addison-
Wesley, 2001
[8] I. SOMMERVILLE, Le génie logiciel et ses applications, Inter-Éditions, 1985
[9] Marie-Claude Gaudel, Précis de génie logiciel, Editions Dunod, 2012
[10] P. ANDRÉ et A. VAILLY,Conception des systèmes d’information : Panorama des
méthodes et techniques, Ellipses, collection TECHNOSUP / Génie Logiciel, 2001
[11] P. ANDRÉ et A. VAILLY, Spécification des logiciels – Deux exemples de pratiques
récentes : Z et UML, Ellipses, collection TECHNOSUP / Génie Logiciel, 2001.