Académique Documents
Professionnel Documents
Culture Documents
ANNEE 2018-2019
Certains utilisent aussi des langages de haut niveau comme des ‘pseudo codes’ pour
décrire les fonctionnalités attendues.
Au niveau le plus abstrait, on peut se contenter des entités à l’interface (‘acteurs’) et des
flots qu’ils s’échangent, sans décomposition en fonctions. On parle alors de ‘diagramme
de contexte’. En faisant apparaître les fonctions et en lesraffinant de plus en plus, on
obtient des DFD à différents niveaux d’abstraction.
La figure 1 donne un exemple de DFD, concernant la sélection des réponses à un appel
d'offre. Il s'agit du diagramme de contexte.
A produit une donnée et attend que B la traite pour en produire une autre, ou
A et B sont des processus autonomes avec un tampon entre eux.
Les DFD peuvent être analysés à le recherche de for mes ‘pathologiques’, comme le
‘trou noir’, le ‘générateur spontané’, etc.
Pour ces raisons les DFD sont soit complétés par d’autres spécifications, soit étendus :
flots de contrôle, tampons, etc. Ils connaissent un très grand succès pour spécifier les
fonctions d’un système à cause de leur simplicité et de leur facilité de compréhension par
des non informaticiens.
Le modèle est souvent enrichi de concepts supplémentaires : un état initial (s 0 S), des
états finaux (F S), notés souvent par un double cercle, des signaux de sortie O
(t : SxI -> SxO), notés souvent par <e,s> sur les arcs (l’entrée e dans un certain état fait
passer à un autre état avec production de la sortie s).
Les limitations de ce modèle sont évidentes. Dans esl systèmes complexes, le nombre
des états peut être énorme et la modélisation complète irréalisable. La seule possibilité
est d’abstraire de nombreux détails. Par ailleurs, il s’agit d’un modèle synchrone ; c’est
à dire qu’à tout instant un état global unique doit être défini et une seuletransition peut
survenir. Il est donc très mal adapté à la description de systèmes asynchrones, où
plusieurs composants évoluent en parallèle de manière assez autonome, comme le
montre l’exemple suivant du producteur/consommateur.
Exemple : modélisation un système producteur consommateur avec un tampon à deux
places ; la modélisation du producteur (2 états), du consommateur (2 états) et du
tampon (3 états) séparément sont simples (cf. Fig.4). La modélisation complète
nécessite un grand nombre d’états (2 x 2 x 3 = 12 états -cf. Fig.5); on parle d’explosion
combinatoire dans les cas complexes ; un état <1, P2, C1> signifie que le tampon est
dans l’état 1 (contient 1 message), le producteur dans l’état P2 (il vient de produire) et le
consommateur dans l’état C1 (il vient de consommer).
Il faut noter que des modèles de machines à états finis structurées ont été proposés qui
contournent cette difficulté. Les machines à état finis sont très utilisées pour la
spécification du comportement des composants élémentaires des systèmes.
Le chiffre 2 sur certains arcs signifie que 2 jetons sont produits par la transition sur cet
arc.
Au contraire, celui de la Fig.8 est vivant, c’est à dire sans possibilité d’interblocage, car
les 2 jetons de R sont consommés et rendus simultanément.
Il existe des techniques mathématiques permettant de prouver des propriétés des
RdP (par exemple, existence d'interblocage ou caractère vivant du réseau). Une
technique de base est la construction de l'arbre de tous les marquages accessibles.
Les RdP permettent de modéliser très facilement le producteur consommateur introduit
dans le paragraphe sur les machines à états finis (cf. Fig.9). On n’observe pas la même
explosion combinatoire du nombre de places car chaque sous système conserve son
état (jeton).
Les RdP souffrent eux aussi de plusieurs limitations que diverses extensions tentent de
contourner : typage des jetons (RdP colorés), ajout de prédicats, ajout de
caractéristiques temporelles au franchissement des transitions, etc. Il s’agit du modèle
de comportement le plus fréquemment utilisé.
les entités, qui sont des collections d’items partageant des propriétés
communes (occurrences d’entités),
les associations (ou relations), qui traduisent l’existence de liens entre entités
(occurrences d’associations entre occurrences d’entités),
les attributs (ou propriétés), attachés aux entités et aux associations et qui les
caractérisent.
Une entité existe indépendamment de ce qui l’entour. Une association n’existe que si
les entités extrémités existent.Chaque entité à un attribut identifiant qui distingue
univoquement chaque occurrence d’entité.
Certains modèles, dits modèles binaires, n’autorisent que des associations entre 2
entités. Les associations peuvent être partielles. Les associations sont souvent
caractérisées par leur cardinalités, qui peuvent être notées de diverses manières. Avec
les notations de Merise, à tout X correspond :
4. Conclusion
Souvent les techniques de spécifications se complètent, en décrivant des vues
complémentaires d’un système. Par exemple, un système peut être spécifié à travers un
diagramme de flot de données (sources d’informations, types d’informations stockées et
échangées, décomposition en fonctions),un schéma EA (structuration des informations)
et des machines à états finis (comportement de certains composants). Les méthodes
tentent de proposer des assemblages efficaces de telles techniques avec des guides
pour les construire et les valider.
Parler des techniques de spécification est comme parler des langages de
programmation. Il n’y a ni langage ni technique idéale, ni langage ni technique
permettant de tout faire. L’informaticien doit avoir une culture assez étendue des
diverses techniques comme des divers langages.
EXERCICES
Exercice 1 Diagramme de contexte et diagramme de flots de données (DfD).
On considère la gestion d’un bureau de location pour plusieurs stations touristiques.
Différents prestataires offrent des locations. Ils peuvent les retirer tant qu’aucune
réservation définitive n’est réalisée. Ils touchent90% du prix de la location.
Les clients adressent des demandes de renseignement. Le bureau y répond par des
propositions de location et d’assurance annulation ou une mise en attente. Le client peut
alors refuser ou demander une réservation en envoyant des arrhes et en souscrivant
éventuellement l’assurance annulation. Si la location choisie est encore libre, elle est
réservée, sinon la demande est mise en attente. Après un délai de 8 jours, la
réservation est confirmée de manière définitive .En cas d’annulation après ces 8 jours,
un pourcentage est dû par le client sauf s’i l a souscrit l’assurance annulation.
L’annulation en cas de mise en liste d’attente est toujours possible sans frais.
La facture est envoyée avant le début du séjour. Un rappel suit en cas de non
paiement. En cas de nouveau défaut de paiement le dossier est transmis au
contentieux.
Dessiner le diagramme de contexte et décomposez-le en un premier niveau de DFD.
Raffiner la gestion des réservations avec des DFD plus détaillés.
b) Vous modélisez un distributeur de boissons. Dans son état initial, il attend qu'on
appuie sur le bouton 'café' ou 'sirop'. Après cette sélection il faut 'confirmer' ou bien
'annuler' si on s'est trompé de boisson. Si on confirme, le distributeur verse la boisson
choisie et pendant cette opération tous les boutons sont inactifs. Quand la boisson est
prête ou si l'on a annulé on se retrouve à l'état initial.
c) Le dernier système à modéliser est une petite usine avec 2 machines et un véhicule.
Le véhicule est utilisé pour charger une machine libre avec une matière première et
pour décharger une machine qui a terminé son travail vers le stock de produits finis.
Votre modèle doit rendre compte du fait que le véhicule ne peut transporter qu'une
chose à la fois et qu'il ne peut amener une matière première que s'il y a une machine
libre.
1. Introduction
Le langage Z a été développé à l’Université d’Oxfor à la suite des travaux de Jean
René Abrial. C’est un langage formel qui utilise :
les notions ensemblistes, le calcul des propositions (et, ou, non, implication, etc.) et
des prédicats (quantificateurs existentiels – il existe - et universel –quel que soit -),
les relations (partie du produit cartésien de plusieurs ensembles) et fonctions
(relations avec au plus une image par valeur du domaine de définition),
les séquences ou suites (fonctions des entiers naturels dans un autre ensemble pour
imposer un ordre aux valeurs).
Nous commentons au paragraphe suivant un exemple de document de spécification en
Z, utilisant uniquement les aspects ensemblistes.
2. Les ensembles
Le document de spécification contient tout d’abord une introduction informelle du
problème traité.
Introduction
Cette spécification concerne l’enregistrement des passagers à bord d’un avion. Les places
ne sont pas numérotées. Les passagers sont autoriséà embarquer selon la règle du
‘premier arrivé, premier servi’.
Sont ensuite décrits tous les types et toutes les variables utiles dans la spécification.
La spécification utilise des ‘ensembles donnés’ dont on ne donne que le nom (‘given
sets’). Elle utilise aussi une boîte à outils mathématique avec des ensembles prédéfinis
comme les entiers naturels (N) ou les booléens.
Types
[PERSONNE] ensemble des personnes identifiées de manière unique
capacité : N capacité de l’avion (c’est un entiernaturel)
OUIOUNON ::= oui | non ( la barre | indique un ou)
REPONSE ::= OK | déjàABord | plein | deuxErreurs
Puis vient la description de l’état du système. Il prend la forme d’un schéma avec un nom,
des déclarations précisant les types, et des propriétés (prédicats) précisant les valeurs.
Etat du système
C’est l’ensemble des personnes à bord. Il ne peut e xcéder la capacité de l’avion.
On décrit ensuite l’état initial du système comme un autre schéma.
On décrit les opérations qui peuvent faire évoluer l’état du système : embarquer,
débarquer. Les schémas correspondants font référenc au schéma Avion qui indique
l’évolution du schéma Avion avant et après l’appeld’une opération (les états après
l’opération sont marqués par une apostrophe).
Les opérations
Les interrogations laissent l’état du système inchangé. Ce qu’indique le schéma suivant
:
Les interrogations
Enfin, le traitement des erreurs peut être spécifié dans un ou plusieurs schémas.
Aujourd’hui, la méthode B et son langage B, également développés par J.R. Abrial, tend
à remplacer la Z. B s’intéresse au processus qui va de la spécification formelle au
programme.
La méthode B offre :
un langage de spécification à base de machines abstraites,
une technique de raffinage des spécifications (des notions abstraites aux notions
des langages de programmation),
des obligations de preuve associées à chaque étape,
un outil permettant de supporter ce processus (l’atelier B, Steria).
Elle a pu être appliquée dans quelques projets de t aille réelle, comme le système
Météor (ligne 14 du métro Parisien) avec 100 000 lignes de B compilées en 87 000
lignes de code ADA et 28 000 preuves.
EXERCICES
Exercice 3.1 : ensembles
On a enregistré des personnes comme utilisateurs d’un système informatique. A un
moment donné, certains utilisateurs sont connectés à l’ordinateur (une seule fois) et
d’autres non.
Spécifier en Z le système ‘ordinateur’ avec les opérations AjouterUtilsateur,
SupprimerUti-lisateur, Connexion, Déconnexion, et les erreurs correspondantes.
1. Définir sur le même modèle, le schéma de la touche droite (flèche à droite) ; attention
aux divers cas liés à la fin de ligne (retour en début de ligne suivante) et à la fin de
l’écran (retour en première ligne, première colonne).
2. Définir le schéma de l’opération LignesRestantesqui retourne le nombre de lignes
restantes au dessous du curseur.
Exercice 3.3 : fonctions
Un système enregistre les réservations de chambres d’hôtel pour une nuit. Etant donné
les types de base
[CHAMBRE] ensemble des chambres
[PERSONNE] ensemble de toutes les personnes possibles on peut représenter l’état
des réservations de l’hôtel par le schéma suivant :
il est important de pouvoir décrire des ensembles, des relations et des fonctions
(ce sont les concepts centraux dans les modélisations objet),
la théorie des ensembles est bien établie dans la culture mathématique,
la théorie des ensembles permet de construire les objets mathématiques évolués
(entiers, arbres, ...) à partir d'un ensemble réduit de composants de base,
la théorie des ensembles permet une écriture concise de notions évoluées.
Nous n'allons pas décrire ici en détail tout le langage de la méthode B, nous nous
contenterons de détailler un petit nombre de concepts qui nous seront utiles par la
suite. Une description plus détaillée est donnée dans l'annexe A de ce document et
dans le manuel de référence. Nous donnons pour chaque notion à la fois la notation
mathématique et une notation ASCII utilisée dans les outils.
Exemple
3 × ( n + 3) / k
Remarque
Dans les outils, une variable est formée d'au moins deux caractères, l'expression
précédente s'écrira en fait :3 * (nn + 3) / kk
Ensembles de base
Ø {} L'ensemble vide
INT INT L'ensemble des entiers relatifs compris entre MININT et MAXINT
Exemple
{1,2,3} est un ensemble.
Compréhension
Soit P une formule, on peut définir un ensemble par compréhension comme l'ensemble
de tous les objets qui vérifient la formule P. On note cet ensemble {z | P}.
n1 < n2 n1 n2 n1 =< n2
math ASCII
math ASCII
¬F not(F) négation
F1 F2 F1 & F2 conjonction
F1 F2 F1 or F2 disjonction
F1 ⇒ F2 F1 => F2 implication
F1 F2 F1 <=> F2 équivalence
N est un type, les machines pourront également être paramétrées par des variables
représentant des ensembles arbitraires. Ces variables sont également des types. Si T1
et T2 sont des types, il en est de même du produit carté sien de T1 et de T2, noté T1 × T2
qui est le type des paires (t1,t2) d'éléments t1 de type T1 et t2 de type T2. Si T est un type,
il en est de même du type des sous-ensembles de T noté P(T). Ainsi si ei T pour
i=1..n, alors {e1,...,en} P(T).
Le langage de B impose que les formules écrites soient bien "typées". Cela permet
d'empêcher a priori de construire des expressions q ui ne représentent effectivement
pas des ensembles comme {x| x x}. Pour cela on impose que chaque variable
introduite soit contrainte à vivre dans un certain ensemble et que ces ensembles
s'organisent de manière cohérente.
Il faut vérifier que les opérations ensemblistes apparaissant dans la formule sont
compatibles avec la hiérarchie. Par exemple si on a x=y alors les types de x et de y
doivent être égaux. Dans la relation x X on doit vérifier que X est de type P(U) pour un
certain type U et que x est de type U. Si on a X Y, on doit vérifier que X et Y sont de
type P(U) pour un certain type U.
Exemple
Nous illustrons la procédure de vérification sur un exemple. On suppose qu'un
ensemble E arbitraire est donné. Soit la formule :
(a,b). (a,b) P(E) × P(E) ⇒ {x | x E x a x b} E
Une substitution élémentaire est de la forme var:=E. Dans ce cas [var:=E]P représente
juste le résultat de la substitution des occurrences libres de var dans P par E.
Exemple
[n:=3]n>m est égal à 3>m.
La variable z est liée dans les formules z.Q et z.Q ainsi que dans l'expression {z|
Q}.
Un même nom de variable peut avoir simultanément de s occurrences libres et des
occurrences liées dans une formule :
n>0 ⇒ n.n 0
Lors de la substitution [var:=E]P, il faut être attentif à ne remplacer que les occu rrences
libres de var dans P et de plus, il ne faut pas que les variables libres de E se retrouvent
liées par des quantificateurs de P
Exemple
Soit la formule P définie comme étant n>0 ⇒ n. m. m n On souhaite calculer
[n:=m+1]P. Une opération naïve de remplacement donnerait lerésultat erroné :
Principe de la substitution
Pour calculer le résultat d'une substitution [var:=E]P on renomme les variables liées de
P de manière à ce qu'elles soient différentes des variables libres de P et de E puis on
procède à un remplacement de var par E dans la formule ainsi obtenue.
[x1,...,xn:=e1,...,en]P
Toutes les variables xi doivent être distinctes. Une substitution multiple peut
alternativement être notée :
Remarque
La substitution est simultanée, en particulier [x,y:=a,b]P n'est pas équivalent à
[x:=a][y:=b]P. L'exemple suivant illustre ce phénomène :
2.4.1 Relations
Dans le tableau suivant, E, E1 et E2 représentent des ensembles tandis que R, R1 et R2
représentent des relations.
P(E1× E2)
R1;R2 R1 ; R2 Composition des relations R1 et R2
(x,y) (E R) (x E (x,y) R)
(x,y) (R E) ((x,y) R y E )
x dom(R) ( y. (x,y) R)
y ran(R) ( x. (x,y) R)
2.4.2 Fonctions
Les fonctions du système B sont, comme en mathématique, des cas particuliers de
relations. Une fonction de E1 dans E2 est une relation binaire sur E1 × E2, c'est-à-dire un
ensemble de couples (x,y) aussi notés x| y. Une relation R est dite fonctionnelle si
lorsque x | y1 R et x | y2 R alors y1=y2. Une fonction f de E1 dans E2 est une
relation fonctionnelle. L'ensemble des relations fonctionnelles de E1 dans E2 est noté E1
+-> E2. Le domaine d'une fonction f est l'ensemble dom(f) des x pour lesquels il existe y
tel que x | y f. Si x est dans le domaine de f alors on note f(x) l'unique y tel que x |
y f.
Une fonction est totale si son domaine est égal à l'ensemble E1 tout entier.
2.4.3 Séquences
Les séquences sont des suites ordonnées d'objets d'un ensemble E. Une manière de
les modéliser mathématiquement est de les voir comme des fonctions de N dans E dont
le domaine est soit l'ensemble vide (dans le cas de la séquence vide) soit l'ensemble
1..n pour n un entier strictement positif. L'ensemble des séquences sur E est noté
seq(E), les principales constructions sur les séquences sont rappelées en annexe
(A.4.3).
2.4.4 Exemple
Les notions que nous avons introduites sont suffisantes pour modéliser un petit
problème.
On s'intéresse à un ensemble de personnes et leurs liens de parenté et de mariage. On
suppose donné, un ensemble personnes représentant les personnes. On cherche à
modéliser de manière ensembliste les notions de femmes, hommes, les relations de
a_pour_epoux, a_pour_épouse, a_pour_mère, a_pour_père, a_pour_frère,
a_pour_enfant, est_marié_à sachant que les principes suivants doivent être re spectés :
On identifie les données minimales qui doivent être primitives (par exemple l'ensemble
hommes, les relations a_pour_epoux et a_pour_mère). Les contraintes imposent des
restrictions sur la nature de ces objets. On peut ensuite définir les autres notions en fonction
des notions primitives.
hommes personnes
femmes = { p | p personnes p hommes}
a_pour_epoux femmes × hommes
a_pour_epoux est une fonction (partielle) de femmes dans hommes :
a_pour_epoux femmes +-> hommes ce qui signifie :
(f | h1 a_pour_epoux f | h2 a_pour_epoux) ⇒ h1=h2
a_pour_epoux est une fonction injective de femmes dans hommes :
a_pour_epoux femmes >+> hommes ce qui signifie :
(f1 | h a_pour_epoux f2 | h a_pour_epoux) ⇒ f1=f2
a_pour_epouseestlafonctioninversedea_pour_epoux:
-1
a_pour_epouse hommes>+>femmeseta_pour_epouse=a_pour_epoux ce qui
signifie :
m | f a_pour_epouse f | m a_pour_epoux
a_pour_mère est une fonction (partielle) de personnes dans femmes :
a_pour_mère personnes +-> femmes
a_pour_père est une fonction (partielle) de personnes dans hommes qui est la
composition de la relation a_pour_mère et de la relation : a_pour_epoux
a_pour_père =a_pour_mère;a_pour_epoux ce qui signifie :
x | p a_pour_père ( m. x | m a_pour_mère m | p a_pour_epoux)
a_pour_enfant est une relation de personnes personnes, c'est la réunion des
relationsinversesdea_pour_mèreeta_pour_père :
a_pour_enfant = a_pour_mère-1 a_pour_père-1 ce qui signifie :
x | y a_pour_enfant (y | x a_pour_mere y | x a_pour_pere)
a_pour_frère est une relation de personnes hommes. Pour trouver les frères, il
faut chercher la mère puis composer avec les enfants de cette mère qui sont des
hommes et qui ne sont pas la personne initiale. Cela donne :
-1
a_pour_frère = ((a_pour_mère ; a_pour_mère ) hommes) - id(hommes)
Modélisation du programme
L'exécution d'un programme transforme l'état de la mémoire de la machine. La partie
qui nous intéresse correspond aux valeurs associées aux variables du programme. On
représente souvent l'environnement d'exécution du programme comme une fonction qui
à chaque variable du programme associe une valeur (entier, chaîne de caractères,
ensemble fini,...)
Exemple
Que fait le programme suivant ? Comment le démontrer?
n:=5;
i:=n; res:=1;
while i > 0 do res:=i*res; i:=i-1 end
print(res)
La logique de Hoare établit un système de déduction qui permet de démontrer des
triplets de Hoare {}P{}
Dans lesquels P est un programme et et sont des formules portant sur les variables
du programme. Lorsqu'un triplet {}P{} est vrai cela signifie que si les valeurs des
variables de P satisfont la formule {} alors après l'exécution de P, les nouvelles valeurs
de ces variables satisferont la propriété .
Exemple-suite
On peut annoter le programme précédent par des assertions
n:=5;
{n 0} i:=n; res:=1;
{res*i!=n!}
while i > 0 do res:=i*res; i:=i-1 end
{i=0 res=n!*i!}
print(res) {res=n!}
{wp(P,)}P{} .{}P{}⇒(⇒wp(P,))
wp(x:=e,)=[x e]
wp(P1;P2,) = wp(P1,wp(P2,))
Exercices
Chapitre Machines abstraites
3.1 Introduction
La notion centrale de la méthode B est la notion de machine abstraite. Afin de
modulariser les développements, les programmes sont décomposés en unités qui ont un
rôle analogue à celui des objets. Chaque machine déclare ses propres variables et
opérations. Les variables ne peuvent être modifiées que par les opérations de la
machine.
Dans la méthode B, les machines comportent également des assertions logiques qui
permettent de préciser des propriétés qui seront satisfaites par les variables et les
opérations. Dans un premier temps les opérations sont spécifiées par leurs propriétés
et non par la manière dont elles seront implémentées.
Les machines abstraites sont décrites à partir de substitutions que nous décrivons dans
le paragraphe 3.2. Nous décrirons ensuite la structure d'une machine abstraite et les
propriétés qui doivent être vérifiées pour assurer que la machine abstraite est bien
construite. Finalement, nous indiquons les principales opérations de composition des
machines abstraites. Dans les sections suivantes, nous décrirons les opérations de
raffinement et d'implantation.
Les substitutions généralisées sont formées à parti des substitutions élémentaires que
nous avons introduites dans le paragraphe 2.3. Les substitutions élémentaires
représentent l'affectation dans les programmes.
Dans le cas de Q ==> S si Q est faux alors on peut montrer (par l'absurde) que [Q ==>
S]P est vrai et cela pour tout P donc on peut établir que toute propriété P est vérifiée
après l'exécution de ce programme, en particulier al propriété absurde. Cela signifie que
le programme correspondant à S n'est jamais exécuté.
VAR x IN S END @ x. S
Restrictions
La substitution VAR ne peut être utilisée dans une machine abstraite d e spécification.
La variable introduite par ANY ne peut apparaître en partie gauche d'une substitution.
Choix booléen
BOOL est un ensemble prédéfini qui comprend les deux valeurs true et false.
Si S est une substitution généralisée et var, var et var des listes de variables alors une
1 2
opération opn du langage B est introduite par une des déclarations suivantes :
1. routines : opn = S
2. procédures : opn(var) = S
3. fonction sans paramètre : var opn = S
4. fonction avec paramètres : var1 opn(var2) = S
Exemple
On peut par exemple définir une opération moyenne qui calcule dans la variable m la
moyenne des variables a et b. Cette opération correspond à la substitution simple :
m:=(a+b)/2
Il est commode de la voir comme une opération prenant comme entrée a et b et ayant
comme sortie m. On écrira donc :
m moyenne(a,b) = m:=(a+b)/2
VAR tmp IN
m moyenne4(a,b,c,d) =
tmp moyenne(a,b);
m moyenne(c,d);
m moyenne(tmp,m);
END
INVARIANT I propriété
INITIALISATION S0 substitution
OPERATIONS substitutions
var1 nom_de_l'opération(var2) = S;
·
·
·
END
VARIABLES x,y
OPERATIONS
v abs = v:=x;
v ord = v:=y;
move(dx,dy) =
THEN (x,y):=(x+dx,y+dy)
END
END
Conditions
Une machine abstraite doit suivre certaines contraintes.
I ⇒ (var1,var2) P ⇒ [S]I
La précondition sur la substitution est essentielle pour assurer que l'invariant est
préservé.
Opérations spécifiées
Il n'est pas nécessaire d'implanter complètement une opération, les machines servent
alors à décrire des spécifications, c'est-à-dire ce que fait l'opération en évitant de décrire
comment l'opération le fait. On peut par exemple vouloir implanter une opération qui
étant donné un ensemble fini de points nous renvoie l'abscisse la plus petite.
px pp_abs(E) =
END
Ensembles
Les modélisations manipulent souvent des ensembles qui restent non spécifiés jusqu'à
la phase d'implantation. Par exemple pour modéliser une base de données, on
introduira l'univers global des objets dans la base qui est un ensemble fini, on pourra
piocher dans cet ensemble pour ajouter de nouveaux objets. Une variable de la
machine abstraite décrit le sous-ensemble de cet univers qui correspond à l'état courant
de la base.
Il est également utile de pouvoir introduire de nouveaux ensemble finis par extension en
énumérant les objets de cet ensemble.
Les ensembles ainsi introduits sont toujours finis et non vide et on convient de les
identifier par des noms en majuscule. Les objets introduits dans l'énumération d'un
ensemble sont tous distincts.
SETS
ENSEMBLE_ABSTRAIT;
ENSEMBLE_EN_EXTENSION={a1,...,an}
Constantes
Il est utile également d'introduire des constantes correspondant à des valeurs
particulières qui restent "symboliques" jusqu'à l'implantation. C'est le cas par exemple
de la taille des ensembles introduits. La déclaration de constantes se fait de la manière
suivante :
CONSTANTS
c1,...,cn
Propriétés
Si les valeurs des constantes et ensembles ainsi introduits ne seront précisées qu'au
moment de l'implantation (ils correspondront à des constantes du programme à
exécuter), il peut être utile d'exprimer des contra intes sur ces objets. C'est le rôle de la
déclaration PROPERTIES des machines abstraites. Cette déclaration introduit une
formule portant sur les constantes et ensembles déclarés qui est supposée être vérifiée.
Exemple
MACHINE Mariages
SETS
PERSONNES;
STATUT={marié,célibataire};
SEXE={homme,femme}
CONSTANTS max_pers
PROPERTIES
VARIABLES
INVARIANT
personnes PERSONNES
INITIALISATION
personnes,sexe,statut:=Ø,Ø,Ø
INITIALISATION
personnes: P(PERSONNES)
|| sexe:=personnes × { femme}
|| statut:=personnes × { célibataire}
OPERATIONS
ajout(s,m) =
END
END
Exercice
Spécifier une opération de mariage.
La machine paramétrée pourra être utilisée avec différentes instances pour les
paramètres.
Les conditions sur les paramètres sont exprimées dans un champ appelé
CONSTRAINTS par une formule ne portant que sur les paramètres de la machine.
Exemple
Nous décrivons une machine abstraite pour spécifier des tableaux.
MACHINE Array(INDEX,VAL)
VARIABLES table
OPERATIONS
enter(i,v) =
THEN table(i):=v
END;
v access(i) =
PRE i INDEX
THEN v:=table(i)
END;
i search(v) =
PRE v ran(table)
END;
b test(v) =
PRE v VAL
END;
3.4.2 INCLUDES
INCLUDES prend en argument une liste de machines M1,...,Mk. Si la machine M inclut
une machine M'(X,x) paramétrée par un ensemble X et un scalaire x, alors les
paramètres seront instanciés dans la clause d'inclusion, on écrira donc INCLUDES
Mi(P,p) où P et p sont respectivement un ensemble et un scalaire de la machine M.
Le fait d'utiliser une clause INCLUDES demande de vérifier des obligations de preuve.
Si la machine M inclut une machine M'(P,p), la condition principale à vérifier est que
l'instanciation a de la machine incluse satisfait bien les contraintes indiquées dans M'.
Cette instanciation peut se faire à l'aide des paramètres, constantes et ensembles de M.
Lorsque deux machines M1 et M2 sont incluses dans une même machine M alors les
variables de M1 et M2 doivent être différentes (de manière à éviter de casser les
invariants de chaque machine). Au besoin, on utilisera une opération de renommage sur
les variables et opérations des machines incluses.
La commande d'inclusion est une facilité d'écriture, il serait possible d'expanser les
déclarations des machines incluses dans la machine principale.
Exemple
On aurait pu découper notre machine Mariages en deux en introduisant tout d'abord une
machine Personnes ne contenant que les personnes et leur sexe :
MACHINE Personnes
SETS
PERSONNES;
SEXE={homme,femme}
CONSTANTS max_pers
PROPERTIES
INVARIANT
INITIALISATION personnes,sexe:=Ø,Ø
OPERATIONS
ajout_personne(x,s) =
END
MACHINE Mariages
SETS STATUT={marié,célibataire};
INCLUDES Personnes
VARIABLES statut
INITIALISATION statut:=Ø
OPERATIONS
ajout(s,m) =
THEN
END
3.4.3 USES
USES prend en argument une liste de noms de machines M1,...,Mk. Les variables,
paramètres, constantes et ensembles des machines utilisées sont visibles dans la
machine M, peuvent être utilisés dans les invariants, substi tutions de M. Cependant la
machine M ne peut voir les opérations des machines de la clause USES et ne peut en
modifier les variables. Les éventuels paramètres des machines Mi ne sont pas
instanciés dans M et doivent être distincts de ceux de M.
L'idée est que dans le futur, une machine N sera construite qui incluera la machine M et
toutes les machines des clauses USES de M. La vérification de la cohérence globale du
système sera faite dans la machine N.
La déclaration USES sert à partager des informations statiques entre deux machines
incluses dans une troisième.
Exemple
En reprenant notre exemple de mariage, une alternative serait de construire une
machine Statut qui utilise la machine Personnes et implante le statut, une opération de
mise-à-jour du statut est introduite. Il n'est pas possible dans la machine Statut de
maintenir l'invariant que statut est une fonction totale sur personnes, en effet la mise à
jour du statut se fait indépendemment des modifications apportées à la variable
personnes. On se contente donc de déclarer statut comme une fonction partielle de
l'ensemble PERSONNES dans STATUT.
La machine Mariage est alors construite dans un troisième temps par inclusion des
machines Personnes et Statut, cette machine peut déclarer l'opération d'ajout et
contraindre la fonction statut à être totale sur personnes :
MACHINE Statut
SETS
STATUT={marié,célibataire}
USES Personnes
VARIABLES statut
INITIALISATION statut:=Ø
OPERATIONS
set_statut(x,m) =
END
INCLUDES
Personnes,Statut
INVARIANT
dom(statut)=personnes
OPERATIONS
ajout(s,m) =
END
END
3.4.4 SEES
SEES prend en argument une liste de noms de machines M1,...,Mk. Les constantes,
ensembles, variables, et les opérations ne modifiant pas les variables des machines
apparaissant dans la clause SEES sont visibles dans la machine M. Cependant les
variables des machines vues sont complètement cachées et ne peuvent être utilisée
dans l'invariant de M, elles sont par contre accessibles en lecture dans les opérations
de M. Lorsqu'une machine M a une clause SEES M', alors c'est que l'implantation de M
comportera en particulier une instance de M'.
Exercices
Exercice 1 : Modélisation de carnet d’anniversaire
On désire Modéliser un carnet d’anniversaire par une machine paramétrée ; Les
opérations possibles sur le carnet sont :
On suppose de plus que le nombre maximal de personnes pouvant être entrées dans
le carnet est fixé.
1. Modéliser le carnet par une machine paramétrée par deux ensembles NOM et
DATE représentant respectivement les univers des noms des personnes et des
dates, ainsi qu'un entier max qui représente le nombre maximal d'entrées dans le
carnet.
2. Reprendre l’exercice pour une machine défensive ou il ne revient pas à
l’utilisateur de faire les différents contrôles : doublon de nom, base pleine, non
cherché existant dans la base.
3. Raffiner la machine pour transformer les ensembles de noms et la relation
d'anniversaire en deux tableaux partageant les même s indices
Chapitre : Raffinement
4.1 Introduction
Le raffinement est une technique utilisée au cours du processus de développement
logiciel pour transformer un modèle abstrait d'un système logiciel (la spécification) en un
modèle plus concret, c'est-à-dire qui contient plus de détails sur la spécification ou bien
qui est plus près d'une implémentation.
Lors d'un raffinement, une machine M1 est remplacée par une autre machine M2 qui va
fournir des opérations de même nom et de même signature mais qui seront implantées
à l'aide de variables d'états différentes ou qui satisferont une spécification plus forte. On
dira que deux opérations ont la même signature s'il s ont le même nombre de
paramètres d'entrée et de sortie et que ces paramètres sont contraints à habiter les
mêmes univers.
Si une opération op2 est un raffinement d'une opération op1 alors toute utilisation de op1
doit pouvoir être remplacée par une utilisation de op2, sans casser le fonctionnement du
programme.
4.2.1 Terminaison
L'interprétation de [S]P est la plus faible condition telle que si elle est vérifiée alors toute
exécution de S termine dans un état qui vérifie P.
Une substitution S correspond donc à un programme qui termine lorsque l'on peut
démontrer [S](x=x). On pourrait en fait remplacer la formule x=x par n'importe qu'elle
formule toujours vraie.
Exemples
Exemples
Lorsque cette condition est vérifiée, on écriraS1 S2 et on dira que S1 est raffiné par S2.
[S1](xx') ⇒ [S2](xx')
Exercice
Montrer les propriétés suivantes :
S S
si S1 S2 et S2 S3 alors S1 S3
si S1 S2 alors
o P|S1 P|S2
o P==> S1 P ==> S2
S1 S1 [] S2
4.4.1 Exemple
On peut se donner une première machine Ens1 qui a pour variable d'état, un ensemble
fini ens d'entiers et une opération d'ajout d'un entier à cet ensemble. Un raffinement de
cette machine consiste à vouloir représenter cet ensemble par un tableau, en
introduisant un index pour la dernière case occupée dans le tableau.
MACHINE Ens1(maxe)
CONSTRAINTS maxe N1
VARIABLES ens
INITIALISATION ens:=Ø
OPERATIONS
ajout(n) =
END
Une machine effectuant les mêmes tâches que Ens1 mais utilisant un tableau aura la
forme suivante :
MACHINE Ens2(maxe)
CONSTRAINTS maxe N1
VARIABLES tab, index
OPERATIONS
ajout(n) =
END
On rappelle que la formule tab 1..index >-> N signifie que tab est une injection (cf
A.4.2).
Pour montrer que Ens2 est un raffinement de Ens1 il faut établir un lien entre les
variables d'état des deux machines. Ici on va demander que l'image de la fonction tab
soit égale à l'ensemble ens.
REFINEMENT Ens2
REFINES Ens1
INITIALISATION index,tab:=0,Ø
OPERATIONS
ajout(n) =
Comme il peut y avoir plus d'initialisation dans Ens1 que dans Ens2 au lieu d'établir
[I2]([I1]Inv2) qui dirait que toutes les exécutions de I1 établissent Inv2 on établit qu'il existe
une exécution de I1 qui établit Inv2, ou encore qu'il n'est pas possible que toutes les
exécutions de I1 établissent ¬ Inv2. La condition est donc :
Dans le cas de l'opération ajout on peut supposer qu'elle va être appelée dans les
conditions requises par Ens1 et que de plus les invariants de Ens1 et Ens2 seront vérifiés.
Il faut vérifier qu'alors la préconditionde ajout dans Ens2 est vérifiée et que, après
l'exécution de la substitution associée dans Ens2, on peut trouver une exécution
de ajout dans Ens1 qui validera Inv2.
En supposant que ajout s'écrit PRE P1 THEN S1 END PRE P2 dans Ens1 et
THEN S2 END dans Ens2, on obtient l'obligation de preuve
Dans l'opération de raffinement, on introduit une machine M2 avec une nouvelle variable
d'état e2 (distincte de e1), un invariant Inv2, une initialisation I2 et contient une opération
op2 de la forme :
On veut montrer que le comportement de op2 est un cas particulier de celui attendu de
op1.
Invariant combiné
Ceci nous amène à introduire un nouvel invariant portant sur les variables de M2 :
Nous allons établir les propriétés portant sur Inv1 et Inv2 pour que Inv soit un invariant
de la machine M2 et que l'opération op2 soit un raffinement de op1.
Initialisation
On retrouve la formule :
Opération
Contrairement au cas précédent, nos opérations ontun paramètre de sortie, il faut donc
établir qu'à entrées égales, la sortie deop2 est un cas particulier de sortie attendue par
op1 ce qui donne :
e1,e2. Inv1 Inv2 ⇒ ( x1,x2. x1=x2 P1 ⇒ (P2 [S2](¬ [ S1] ¬ ( y1=y2 Inv2))))
Exercices
Exercice 1 : Modélisation et raffinage de carnet d’anniversaire
On désire Modéliser un carnet d’anniversaire par une machine paramétrée ; Les
opérations possibles sur le carnet sont :
On suppose de plus que le nombre maximal de personnes pouvant être entrées dans
le carnet est fixé.
4. Modéliser le carnet par une machine paramétrée par deux ensembles NOM et DATE
représentant respectivement les univers des noms des personnes et des dates, ainsi
qu'un entier max qui représente le nombre maximal d'entrées dans le carnet.
·
·
·
END
5.1 Principes
Les implantations respectent certaines règles :
Toutes les autres substitutions ANY, SELECT, LET ... ne sont pas autorisées dans les
implantations.
Une expression simple est une variable locale, ou une variable d'entrée ou bien une
constante (des machines raffinées, importées ou vues) ou un littéral (constante entière,
valeur booléenne TRUE ou FALSE).
Les expressions généralesqui peuvent être utilisées dans une implantation p euvent
être soit une expression simple ou bien une express ion arithmétique construite à partir
des opérateurs d'addition, de soustration, de multiplication, de division, de reste modulo
ou d'exponentiation.
Dans les conditions des substitutions IF ou WHILE, les expressions peuvent être
formées à partir des connecteurs ¬, , and ⇒ et des formules de comparaison
d'expressions simples.
Une implantation va être construite en combinant d' autre machines plus élémentaires
suivant un principe de développement en niveaux. En général on utilisera les
descriptions abstraites des machines élémentaires qui elles-mêmes seront raffinées et
implantées. On pourra utiliser les machines des bibliothèques présentes dans les outils
de développement.
La clause VALUES est suivie d'un ensemble de déclarations id=valeur séparées par
des points virgules. id est le nom de la donnée à valuer et valeur sa valeur. L'ordre des
valuations est important. Une constante ne peut êtr e utilisée dans la partie valeur que si
elle a été préalablement définie.
P est un prédicat (la condition de la boucle, S est une substitution (le corps de la
boucle), I est un prédicat, l'invariant et V est une expression, le variant qui représente
une grandeur qui diminue à chaque passage dans la boucle mais reste positive.
r MinSet(c) =
PRE c P1(N)
THEN r:=0;
WHILE r c DO r:=r+1
END
END
5.6 Exemple
Nous prenons un exemple de machine représentant un ensemble fini (ici d'entiers non
nuls), qui permet d'ajouter des éléments mais également de calculer le maximum de
l'ensemble. La spécification de la machine est la suivante :
MACHINE MaxEns
VARIABLE ens
INITIALISATION ens := Ø
OPERATIONS
enter(n) = PRE n N1 THEN ens:=ens {n} END;
END
Comme la seule opération à réaliser sur l'ensemble stocké dans cette machine est de
trouver le maximum, il n'est pas utile de garder un ensemble arbitraire, on peut se
contenter d'une variable entière. On obtient donc le raffinement :
REFINEMENT MaxEns1
REFINES MaxEns
VARIABLES mEns
INITIALISATION mEns := 0
OPERATIONS
END
Exercice
Énoncer les obligations de preuve
REFINEMENT MaxEns2
REFINES MaxEns1
VARIABLES mEns
INITIALISATION mEns := 0
OPERATIONS
enter(n) = IF n mEns THEN mEns:=n END;
END
La variable de la machine MaxEns2 ayant le même nom que celle de la machine MaxEns1,
un invariant implicite disant que ces deux variables sont égales est ajouté.
Pour implanter notre exemple, nous avons besoin d'une variable entière qui sera
obtenue en important une machine implantant une variable entière :
MACHINE Scalar(initval)
CONSTRAINTS initval N
VARIABLES z
INVARIANT z N
INITIALISATION z:=initval
OPERATIONS
END
REFINES MaxEns2
IMPORTS Scalar(0)
INVARIANT z = mEns
OPERATIONS
enter(n) =
VAR v
IN v value; IF n v THEN modify(n) END
END;
END
Exercices
Exercice 1 : Modélisation et raffinage de carnet d’anniversaire
On désire Modéliser un carnet d’anniversaire par une machine paramétrée ; Les
opérations possibles sur le carnet sont :
On suppose de plus que le nombre maximal de personnes pouvant être entrées dans
le carnet est fixé.
1. Modéliser le carnet par une machine paramétrée par deux ensembles NOM et
DATE représentant respectivement les univers des noms des personnes et des
dates, ainsi qu'un entier max qui représente le nombre maximal d'entrées dans le
carnet.
2. Reprendre l’exercice pour une machine défensive ou il ne revient pas à
l’utilisateur de faire les différents contrôles : doublon de nom, base pleine, non
cherché existant dans la base.
3. Raffiner la machine pour transformer les ensembles de noms et la relation
d'anniversaire en deux tableaux partageant les même s indices
4. Ecrire l’implantation de la machine des carnets d’adresse en utilisant une
machine Arr qui encapsule un tableau (variable arr avec des opérations d'accès
et de mise à jour) et une machine Nvar pour implanter une variable entière var.
utiliser deux tableaux (l'un pour les noms, l'autre pour les dates), lors de l'import,
un préfixe pour distinguer les deux instances.
B.4.1 Machine auxiliaire : variable
Pour la machine qui implante une variable entière, nous utilisons des opérations
de lecture et d'incrémentation.
MACHINE Nvar(maxn)
CONSTRAINTS maxn : N1
VARIABLES nvar
INITIALISATION nvar:=0
OPERATIONS
inc_nvar =
END
B.4.2 Tableaux
Pour les tableaux, nous aurons besoin des opérations d'accès à une valeur, de
mise à jour ainsi que d'une fonction de recherche d'un élément dans un sous-
ensemble du tableau. Cette opération renvoie un booléen qui dit si l'élément a été
trouvé et dans le cas positif renvoie le plus petit indice où l'élément figure.
MACHINE Arr(TYPE,maxn)
CONSTRAINTS maxn : N1
SEES Bool_TYPE
VARIABLES arr
INITIALISATION arr:=Ø
OPERATIONS
sto_arr(i,v) =
b,k ch_eql_arr(i,j,v) =
PRE i..j dom(arr) i j v TYPE THEN
IF v arr[i..j]
THEN b:=TRUE ||
ELSE b:=FALSE||k:TYPE
END
END
END
6 Conclusion
La méthode B introduit un langage logique rigoureux pour représenter les programmes
(substitutions généralisées) et les propriétés dees cprogrammes. Elle utilise une notion simple de
Machine Abstraite qui est assez voisine de la notion d'objet en programmation mais qui intègre
de plus la notion d'Invariant qui assure la préservation de propriétés des variables d'état de la
machine quelles que soient les opérations appliquées.
Des outils permettent de développer des systèmes enutilisant la méthode B. Ces outils offrent
différentes fonctionnalités :
Cette méthode a pu être appliquée avec succès dansdes applications industrielles critiques.
Annexe : Eléments du langage
de la méthode B
Dans cette annexe, nous récapitulons le constructions avancées de la méthode B qui
seront utilisées dans ce cours. Nous indiquons dans la première colonne la notation
mathématique et dans la seconde la notation ASCII utilisée dans les outils.
e1 + e2 e1 + e 2 Addition
e1 - e2 e1 - e2 Soustraction
-e -e Moins unaire
e1 × e2 e1 * e2 Multiplication
e1 / e2 e1 / e2 Division entière
e2 Puissance
e e1 ** e2
1
Ø {} Ensemble vide
math ASCII
E1 E2 E1 \/ E2 L'union des ensembles E1 et E2
math ASCII
max(E) max(E) L'entier maximal d'un ensemble fini non vide d'entiers E.
min(E) min(E) L'entier minimal d'un ensemble fini non vide d'entiers E.
e1=e2 e1e2 e1 /= e2
n1 > n2 n1 n2 n1 >= n2
n1 < n2 n1 n2 n1 <= n2
math ASCII
¬F not(F) négation
F1 F2 F1 & F2 conjonction
F1 F2 F1 or F2 disjonction
F1 ⇒ F2 F1 => F2 implication
F1 F2 F1 <=> F2 équivalence
math ASCII
E1 E2 E1 <-> E2 L'ensemble des relations entre éléments de E1 et de E2
P(E1× E2)
(x,y) (E R) (x E (x,y) R)
(x,y) (R E) ((x,y) R y E )
math ASCII
A.4.2 Fonctions
math ASCII
f E1 +-> E2 ( y. x. x| y f)
f E1 --> E2 ( y. x. x| y f)
f E1 >-> E2 f E1 -->> E2
A.4.3 Séquences
Dans le tableau suivant, s1 et s2 représentent des séquences, e, e1,...,en des
expressions quelconques.
math ASCII
Chaînes de caractères
Les constantes correspondant à des chaînes de caractères sont écrites entre guillemets
comme "Hello".
FICHE DE TD INL53 : GENIE
LOGICIEL
Questions de cours
Exercice 1 : Développer une liste de 20 à 30 qualités du logiciel.
Procéder à une définition concise de chaque attribut
Exercice 3 : Donner sous forme d’un tableau les différentes étapes pour la
planification d’un projet de développement d’un logiciel
Exercice 4 : Expliquer les attributs qualité suivants : portabilité, fiabilité,
erreur, robustesse, correction.
Exercice 5 : Décomposer les attributs qualité en termes de caractéristiques du code-
source
Exercice 6 : Donner le cycle de vie d’un produit logiciel
Exercice 7 : Expliquer en quelques mots les qualités suivantes d’un document
contenant le plan des besoins : correct, complet, consistant, non ambigu,
fonctionnel, vérifiable, traçable, facilement changeable.
Exercice 8 : Nommer quelques méthodes formelles pour la spécification d’un
problème.
Dire en quoi elles sont importantes.
Exercice 9 : Définir logiciel, développeur, programmeur, produit, code-source.
Exercice 10 : Définir le principe secret (information hiding). Qui en est l’inventeur ?
Exercice 11 : Expliquer stepwise refinement. Qui en est l’inventeur ?
Exercice 12 : Utiliser la méthode de raffinement par étape (stepwise refinement)
pour calculer les n premiers nombres premiers.
Exercice 14 : Qu’est-ce que le « Code-and-Fix » ? Donner ses avantages et ses
inconvénients.
Exercice 16 : Qu’est-ce qu’un cahier de charges ?
Exercice 17 : Quels sont les buts de la phase de définition et d’analyse ?
Exercice 18 : Donner les destinataires possibles pendant la phase d’analyse
Exercice 19 : Faites une étude comparative des Standards ANSI/IEEE et le Standard du
Modèle V.
Exercice 20 : Définir génie logiciel
Exercice 21 : Peut-on parler des sciences de l’ingénieur pour le génie logiciel ? Discuter
à partir d’une étude comparée avec une discipline d’ingénieur bien maîtrisée.
Exercice 22 : Qu’est-ce que la crise du logiciel ? Quand est-elle apparue ?
Donner les conditions de sa naissance.
Exercice 23 : Selon quels concepts peut-on valider les besoins ?
Exercice 24 : En quoi le développement des prototypes est-il important dans le
génie logiciel ?
Exercice 25 : Donner les avantages de la gestion de la configuration
(configuration management) par rapport à la gestion des versions (version
management).
Exercice 26 : Quels sont les critères de qualité pour un logiciel ? Qu’appelle-t-on
mesures de qualité
Exercice 29 : Donner la signification des abréviations suivantes : E/A, DFD, OOA,
OOD, UML, CASE, VDM, SA, SD, OMT, SADT
Exercice 30 : Qu’est-ce que c’est que le diagramme des flux de données ? A quoi cela
sert-il ? Qui en est l’inventeur ? Quels sont ses éléments primordiaux ? Donner leur
syntaxe et leur sémantique.
Exercice 33 : Enoncer la méthode de substantifs pour identifier les classes. L’appliquer
à un système concret, par exemple la gestion d’une bibliothèque.
Exercice 36 : Quel est l’avantage principal des langages de modélisation formels sur
ceux semi-formels ? Quels sont leurs inconvénients ?
Exercice 37 : Pourquoi l’abstraction est-elle importante dans le génie logiciel?
Exercice 38 : Quels sont les fondements théoriques du langage de spécification Z ?
Exercice 39 : Combien de langages existe-t-il dans UML ? A quoi servent-ils ?
Exercices de conception
EXERCICE ESEKA
Suite aux nombreux drame sur les routes et chemin de fer au Cameroun, On se
propose de faire l’analyse et modélisation d’un nouveau système de surveillance des
patients dans une unité de soins intensifs. « ...Le système sera installé dans l’unité de
soins intensifs de l’hôpital. Cette unité comporte 8 lits destinés à recevoir des patients
dont l’état est critique et dont les signes vitaux doivent être surveillés 24/24. Les signes
vitaux à surveiller sont l’électrocardiogramme (ECG), le rythme respiratoire (RR) et la
pression artérielle (P) pris par le cardiopad d’Arthur. La surveillance consiste à traiter
les signes vitaux, à les afficher sur des moniteurs au poste des infirmièrs, à les
comparer avec une banque de référence et à émettre éventuellement des alarmes. Les
bornes de référence sont fixées par les médecins. Le système doit produire des rapports
sur chaque patient sur demande des infirmières. Des capteurs en place devront être
utilisés. Le système devra être opérationnel dans un an... »
- Construire le diagramme de cas d’utilisation de ce système.
- Construire le diagramme de classe
- Décrire un scénario et proposer un diagramme de séquence
Exercice 10 : COCOMO
En appliquant la méthode COCOMO estimer la taille moyenne de l'équipe qui faudrait
prévoir pour développer un logiciel estimé à environ 40 000 instructions sources
(SLOC), le projet est simple et l’équipe du développement est relativement réduite.
Exercice 11 : PERT
TACHES PREDECESSEURS DUREE
A - 4
B A 8
C B 5
D - 2
E - 12
F A, D 4
G D, E 7
H C, F, G 10
Tableau 3-1
Phase Effort/Effort total
Plan et expression de 6%
besoin
conception 16%
Implémentation 56%
Intégration et test 22%
4) à T0+9 mois, le décompte des lignes de code laisse penser que la taille du
logiciel sera de l’ordre de 80 KLS.
Recalculer l’effort et la durée nécessaire au développement de ces 80 KLS.
Calculer le surcroit d’effort nécessaire pour terminer le projet.
A quel moment le chef de projet aurait-il pu, ou du tirer le signal d’alarme en
indiquent à son directeur que ni l’effort, ni les délais de réalisations n’étaient
raisonnables ?
Université de Maroua Génie Logiciel et projets
Ecole Normale Supérieure code UE : INL53
Département d’informatique HAYATOU Oumarou
CC de Rattrapage (2 h)
Année académique : 2013 /2014
Exercice 2 : 2points
Définir versionnage. (0,25pt)
Définir et donner des exemples concrets pour les notions de bases de branches, copies de
travail, repository, résolution de conflit, en rapport avec le versionnage. (1pt)
Donner les avantages de la gestion de la configuration (configuration management) par
rapport à la gestion des versions (version management). (0,75)
Exercice 3 : Analyse d’un projet de développement logiciel (16 pts)
Le responsable du projet EtabPrimaire de la société DeptInfoEnsMra a établi le devis du
développement du logiciel EtabPrimaire sur les bases suivantes :
- Conception générale du produit (4mois) ;
- Codage (12mois) ;
- Qualification (2mois) ;
suite aux recommandations du directeur technique de DeptInfoEnsMra.
Ce dernier, pour assurer une bonne rentabilité du projet, estime que dix personnes en
moyennes, sont amplement suffisantes pour une durée de développement de 18 mois. (ce qui
inclus obligatoirement des congés).
La montée en puissance de l’équipe est programmé comme suit :
- A T0 : 4 analystes architectes, dont le chef de projet,
- A T0 + 4 mois : passage à 10 personnes ;
- A T0+6 mois : complément d’effectif pour produire effectivement le budget
alloué (qualification du produit).
Model
State
Query State
Chang
Change e
Notification
User Gesture
View Controlle
View Selection r
Event
s invocations
Method
View : son rôle principal est de présenter les modèles, d’envoyer les actions d’utilisateur au
modèle de contrôle.
Controller : c’est lui qui définit le comportement de l’application en fonction des actions
utilisateur, il assure également les correspondances entre les actions utilisateurs et les
modifications. Enfin il sélectionne les vues pour la réponse.
Model : répond aux requêtes en notifiant les changements. C’est ce module qui « connait » les
fonctions de l’application.
Ce design pattern permet de rendre indépendantes les fonctionnalités de l’application (model)
de la représentation (view) et du comportement de l’application (controller).
Annexe 2 : documents fablog
a) historique des versions
Dates Actions
10/01/2013 DeptInfoEnsMra (DI) commence le developpement de la version 2013 de l’application sur
la une base de 267 hj ( coût supporté par DI de 200hj ). Ce chiffrage ne tient pas compte
des évolutions 2013 qui seront chiffrées à la redaction d’une nouvelle version du cahier
des charges sytème.
01/02/2013 DI livre la nouvelle version du cahier de charges fonctionnel (dont la réalisation a
necessité 2 personnes à plein temps pendant 6 semaines)
Semaine du DI organise une réunion de 2 heures par jour pour répondre aux questions fonctionnelles.
4/02
06/02 au Réunion toute la journée avec le client pour répondre à toutes les questions fonctionnelles
11/02 (sur place, avec accès sans problème au client)
15/02/2013 Le cahier des charges fonctionnels est complété
18/02/2013 DI acte que toutes les questions fonctionnelles ont été répondues, présente le planning de
developpement (base du planning de la commande) et chiffre les évolutions 2013 (-3,5 hj
par rapport à l’estimation du 10/01/2013)
10/05/2013 Annonce d’une dérivé de 4 hj + 1er renforcement de l’équipe (6 personnes). L’équipe
initiale étaient constituée de : 1Chef de projet + 1 Analyste + 2 developpeurs + demande
d’autorisation pour le soir et le week-end. DI indique c’est un signe de retard car ces
réssources sont utilisées tout de suite
13/05/2013 DI indique que l’avancement de la rédaction des spécifications présentes des signes de
retard (2 à 3 jours de retard + détection des incohérences) et qu’il y a une dérive de 50%
sur la réalisation du lot1
10/07/2013 DI annonce 20 hj de retard et un 2ème renforcement de l’équipe (+ 2 personnes). Donc
maintenant il y a 12 personnes dans l’équipe
27/07/2013 DI annonce 40 hj de retard et une restructuration de l’équipe. Actuellement l’équipe est
constituée de 0 développeurs et 4 personnes pour l’encadrement dont 1 directeur de
projet.
Exercice 2 : langage Z
Soit les schémas Z suivants:
Exercice 4 : PERT
La décision vient d’être prise d’acquérir un vidéo projecteur personnalisé pour
le département d'informatique pour les journées portes ouvertes. Les tâches à réaliser
ainsi que leurs durées sont répertoriées ci-dessous. Le travail consiste à déterminer
dans quel délai le matériel sera opérationnel ; pour mener à bien cette mission on
utilise le réseau PERT.
Tracez le réseau PERT en faisant apparaitre le chemin critique, la durée totale
de fabrication du vidéo projecteur ainsi que les marges totales.
Tâches à réaliser Durée (semaines) Code Antériorité
Collecte de la documentation sur les 2 A ----
vidéos projecteurs
Choix du matériel 1 B C
Etude de la documentation 2 C A
Installation du vidéo projecteur 1 D F
Passation de la commande 1 E B
Délai de livraison 4 F E
Commande du chevalet 3 G I
Etablissement d’un projet d’achat de 2 H B
chevalet
Mise au point 2 I H
Formation des opérateurs 2 J D–G
Université de Maroua Génie Logiciel et projets
Ecole Normale Supérieure code UE : INL52
Département d’informatique HAYATOU OUMAROU
Examen Final 2014 /2015 Durée : 2 h
Exercice 3 : COCOMO 81
La société INFO3 doit réaliser un système de gestion de l’ENS de Maroua. Le
tableau suivant résume la situation :
Module Type Nombre de lignes (en KLS) Facteurs de de couts
Scolarité E 30 RELY=1,15
ACAP=0,86
AEXP=0,82
VEXP=0,9
Œuvres Sociales P 120 néant
Restauration S 35 AEXP=0,91
LEXP=1,07
MODP=0,91
Formation à distance S 50 néant