Dan Garlasu, dgarlasu@yahoo.

com

1
  Les Douze Principes Agiles sont basés
sur les 4 valeurs Agiles que nous avons
vues la foi passe. Ces principes visent à
créer et à soutenir une approche de
développement de logiciels axée sur les
besoins des clients et l'évolution des
forces du marché grâce à laquelle de
meilleurs résultats sont obtenus grâce à
un système flexible.

Le manifeste Agile a été publié en 2001 par le travail combiné de 17 professionnels du

développement logiciel qui ont reconnu la nécessité d'un meilleur processus de
développement logiciel. Ce manifeste a été construit sur 4 valeurs Agile et 12 principes
Agile.

3
1. L'approche Kanban utilise des visuels pour voir l'avancement du travail effectué et le travail restant. Les projets
Kanban sont généralement gérés via un tableau appelé tableau Kanban qui comporte 3 segments, à savoir « To Do
», « Doing » et « Done ». Il n'y a pas de rôles formels dans le cadre Kanban.
2. Scrum est assez similaire à Kanban en utilisant un tableau similaire au tableau Kanban appelé tableau Scrum. Ce
tableau permet de suivre l'avancement des travaux. Le cadre Scrum se concentre sur la décomposition du travail en
itérations appelées sprints et l'équipe Scrum ne peut planifier et exécuter qu'un seul sprint à la fois. Scrum a 3 rôles à
savoir Scrum master, product owner et développeur.
3. L'Extreme Programming (XP) est une méthodologie qui agit sur le travail d'équipe, la communication et les retours
reçus. Il est similaire à Scrum dans la manière d'utiliser des cycles de développement plus courts appelés Sprints.
Cette technique est très utile dans un environnement dynamique où les besoins des clients changent.
4. Crystal est un groupe de méthodologies de développement agiles plus petites qui comprend Crystal Yellow, Crystal
Clear, Crystal Red, Crystal Orange, etc. Chacun d'eux a un cadre unique et nous devons en choisir un en fonction de
facteurs tels que la criticité du système, la taille de l'équipe et les priorités du projet.
5. Le DSDM (Dynamic Systems Development Method) a été créé pour disposer d'un cadre industriel commun pour la
livraison rapide de logiciels. Il est basé sur une approche axée sur les affaires et il a fourni huit principes, il permet
des modifications au projet, mais la qualité avec une livraison dans les délais ne doit jamais être négociée. DSDM a
également utilisé des Sprints.
6. FDD (développement piloté par les fonctionnalités) est utilisé pour créer des modèles logiciels toutes les deux
semaines. Ce cadre nécessite de faire des plans de développement et de conception pour chaque fonctionnalité du
modèle. Étant donné que cette approche est plus rigoureuse en matière d'exigence de documentation, elle convient
mieux aux équipes ayant des capacités avancées de conception et de planification.
7. Lean Software Development is often used with Agile and used interchangeably. But it is a completely different
methodology that shares most of the values as Agile.
8. Scaled Agile Framework (SAFe) is a set of organizational and workflow patterns for implementing Agile practices at
the enterprise scale.
4
 Souce: https://scrumorg-website-prod.s3.amazonaws.com/drupal/inline-images/2022-10/scrum_framework.png

Scrum est un cadre Agile qui suit une approche incrémentielle et itérative du
développement et se concentre sur des projets complexes. Ken Schwaber et Jeff
Sutherland ont lancé l'idée d'utiliser Scrum comme framework pour le développement
de logiciels en 1995. Initialement, il n'était utilisé que dans le développement de
logiciels, et en raison de son succès, il est maintenant utilisé dans divers domaines tels
que les ventes, la recherche, le marketing. , et plus.

Le nom Scrum est dérivé du sport de rugby où les deux équipes se réunissent pour
prendre possession du ballon après l'arrêt du jeu en raison d'une infraction à la belle-
famille. Les mêlées impliquent huit joueurs de chaque équipe, qui se lient et se
poussent les uns contre les autres. Dans ce contexte de développement logiciel,
Scrum est l'endroit où l'équipe se rassemble pour faire avancer le produit.

5
Source: https://www.tuleap.org/wp-content/uploads/2020/06/Scrum-process-schema-EN-small.png

6
 Paradigme de programmation Impératif (Procédural)
 Paradigme orienté sur l’objet
1. Introduction
2. Objects
3. Classes

7
Composantes d'un programme impératif :
1. Instructions déclaratives - donnez un nom à une valeur.
◦ Variable - valeur nommée
◦ Les instructions déclaratives créent des variables
◦ Dans les langages procéduraux, il est courant que la même variable continue de
changer de valeur au fur et à mesure que le programme s'exécute.
2. Instructions impératives - attribuez de nouvelles valeurs aux variables
3. Instructions de contrôle de flux de programme - définissez l'ordre dans
lequel les instructions impératives sont évaluées.
Example:

var factorial = 1; /*instruction déclarative*/

var argument = 5;
var counter = 1;
while (counter <= argument) /*Instruction contrôle de flux*/
{
factorial = factorial*counter; /*instruction impérative*/
counter++;
}

Example:
var factorial = 1; /*Declarative statement*/
var argument = 5;
var counter = 1;
while (counter <= argument) /*Program flow statement*/
{
factorial = factorial*counter; /*Imperative statement*/
counter++;
}

8
 Différentes variables dans un programme peuvent avoir différents types :
◦ Par exemple, un langage peut traiter deux octets comme une chaîne (séquence) de caractères ou
comme un nombre.
◦ Diviser une chaîne '20' par le nombre '2' peut ne pas être possible. Un langage comme celui-ci a au
moins deux types - un pour les chaînes et un pour les nombres.
◦ Exemple:
 var NomPersonne = new String(); /*type de variable "chaîne"*/
 var SalairePersonne = new Integer(); /*variable de type "entier"*/
 Les types peuvent être faibles ou forts.
◦ Type fort - à tout moment du programme, lorsqu'il est en cours d'exécution, le type d'un bloc de
données particulier (c'est-à-dire une variable) est connu.
◦ Type faible - les opérateurs impératifs peuvent modifier un type de variable

Les types peuvent être faibles ou forts. Un type fort signifie qu'à tout moment du
programme, lorsqu'il est en cours d'exécution, le type d'un bloc de données particulier
(c'est-à-dire une variable) est connu. Un type faible signifie que les opérateurs impératifs
peuvent modifier un type de variable.

Example:
var PersonName; /*variable of a weak type”*/
PersonName = 0; /*PersonName is an “integer”*/
PersonName = ‘Nick’; /*PersonName is a “string”*/
De toute évidence, les langages prenant en charge les types de variables faibles ont besoin
de règles sophistiquées pour les conversions de types.

Example:
var PersonName; /*variable of a weak type”*/
PersonName = 0; /*PersonName is an “integer”*/
PersonName = PersonName + ‘Nick’ + 0; /*PersonName is a string “0Nick0”*/
Pour prendre en charge le typage faible, les valeurs sont encadrées avec des informations
sur leur type - la valeur et le type sont ensuite transmis ensemble dans le programme

9
 Section de code séparée du programme principal et cachée derrière une interface
 Le code dans la fonction exécute une activité particulière
 L'idée de diviser le code en une sous-routine est de fournir un point d'entrée unique

Les programmeurs ont rêvé/tenté de construire des systèmes à partir d'une

bibliothèque de composants logiciels réutilisables liés avec un peu de nouveau
code.
Le paradigme de programmation impérative (procédurale) est essentiellement
basé sur le concept de soi-disant «fonctions» également appelées «modules»,
«procédures» ou «sous-routines». A voir les différences dans le diapo suivante!
 La procédure principale détermine le flux de contrôle de l'application
 Les fonctions sont appelées pour effectuer certaines tâches ou une logique
spécifique
 Les procédures principales et secondaires qui composent la mise en œuvre
sont structurées comme une hiérarchie de tâches.
 La source de l'implémentation est compilée et liée à tous les modules
exécutables supplémentaires pour produire l'application

10
 Quelle est la différence entre un sous-programme et une fonction?
a) Pas de différence, c’st la même chose
b) Las Fonctions sont pareilles avec les sous-programmes, sauf
qu'elles renvoient un résultat à l'appelant. Les sous-programmes
exécutent une tâche mais ne signalent rien au programme appelant.

Qu’est-ce que c’est le Macro?

Response:
Par exemple, au langage Perl, les sous-programmes sont des morceaux de code que
nous fournissons à Perl. Les fonctions sont similaires aux sous-routines, sauf qu'elles
renvoient une valeur. Une fonction effectue généralement des calculs et rapporte le
résultat à l'appelant. Les sous-programmes exécutent une tâche mais ne signalent rien
au programme appelant.

Une macro-instruction en programmation informatique est une instruction unique qui,

lorsqu'un programme est compilé, est remplacée par un bloc de code prédéfini. Le
terme était à l'origine appliqué aux instructions utilisées dans la programmation en
langage assembleur, dans lequel un code long et répétitif était parfois nécessaire pour
des opérations très simples.

11
  Chaque procédure peut avoir un certain nombre de variables spéciales appelées paramètres.
Les paramètres sont simplement des espaces réservés pour certain nommes (arguments) qui
seront remplacés par des valeurs particulières (ou des références à des valeurs existantes)
d'arguments lorsque la procédure est appelée.
 Example:
function main()
{
var argument = 25;
var result = factorial (argument)
/* Remarque: l'opérateur impératif remplace l'espace réservé "paramètre" par une valeur actuelle de la variable "argument"*/
}
------------------------------------------------
function factorial (parameter)
{
var i = 1;
var result = 1;
while(i <= parameter)
{
result = result * i;
i++;
}
return(result);
}

Lorsqu'une fonctionnalité d'un système logiciel est décomposée en un certain nombre

de modules fonctionnels, l'échange/flux de données devient un problème clé. Le
paradigme de programmation impérative (procédurale) étend le concept de variables à
utiliser comme mécanisme d'échange de données.

12
  Il y a deux manières de passer des arguments aux fonctions
1. Passer une valeur d'argument – dans ce cas, les variables utilisées comme arguments
pour appeler des sous-routines ne peuvent pas être modifiées par des opérateurs
impératifs à l'intérieur des sous-routines
2. Passer une référence d'argument - les variables utilisées comme arguments pour
appeler des sous-routines peuvent être modifiées par des opérateurs impératifs à
l'intérieur des sous-routines
 Langages polymorphes
◦ Permet à «quelconque (any)» d'être inclus dans le type de système
◦ Permet de combiner des fonctions mises en œuvre au moyen de différents langages de
programmation prenant en charge des types de variables potentiellement différents

Il peut y avoir deux techniques différentes pour un tel remplacement, connues sous le nom de : transmission
d'une valeur d'argument et transmission d'une référence d'argument.
• Passage du valeur d’un argument - l'argument actuel est dupliqué en tant que valeur pour le nouveau
paramètre créé dynamiquement pour la procédure.
• Passage d'une référence - la sous-routine prend le contrôle (c'est-à-dire la référence) d'une valeur
actuelle de la variable d'argument.
Ainsi, les types de variables définis comme paramètres d'une fonction doivent être équivalents (ou au moins
compatibles avec) les types de variables (constantes) utilisées comme arguments.

Lorsque le typage statique fort est appliqué, il peut être difficile d'écrire des algorithmes génériques, c'est-à-
dire des fonctions qui peuvent agir sur une gamme de types différents. C’est pour cela que le
polymorphisme a été perfectionné dans les langages orientés objet, mais a ses racines dans les langages
procéduraux. Le polymorphisme s'appuie sur le système de type d'une langage pour distinguer différentes
significations pour le même identifiant. Cette ambiguïté introduit de la flexibilité et permet la réutilisation du
code.
Les langages de programmation ont évolué d'origines non typées à travers des langages monomorphes à
des langages polymorphes. Les langages non typées prennent en charge les mots d'une taille fixe. Les
langages d'assemblage et BCPL en sont des exemples. Les langages typés prennent en charge des régions
de mémoire de différentes tailles distinguées par leur type. Les langages typés peuvent être monomorphes
ou polymorphes. Dans un langage monomorphe, le type d'un objet, une fois déclaré, ne peut pas changer
tout au long de la vie de l'objet. Les langages polymorphes relâchent cette relation entre le type de l'objet et
une région de la mémoire en introduisant une certaine ambiguïté. Le type d'un objet polymorphe peut
changer au cours de sa vie. Cette ambiguïté rapproche les descriptions d'objets de l'usage du langage
naturel.

13
Normalement, les variables définies dans une Example:
function one()
fonction sont créées chaque fois que la fonction {
est utilisée et détruites à nouveau lorsque la var dynamicLocalVariable = 25;
fonction se termine. La valeur renvoyée par la two();
/* at this point just one variable “dynamicLocalVariable” exists */
fonction n'est pas détruite, mais il n'est pas alert(dynamicLocalVariable);
possible d'attribuer une valeur à la variable à /* this operator displays the current value “25” */
l'intérieur de la définition de la fonction depuis }
function two()
l'extérieur. Ainsi, il y a: {
◦ Variables locales dynamiques - sont créées var dynamicLocalVariable = 55;
chaque fois que la fonction est utilisée et /* at this point two variables “dynamicLocalVariable” exists */
alert(dynamicLocalVariable);
détruites à nouveau lorsque la fonction se /* this operator displays the current value “55” */
termine }

Example:
function one()
{
var dynamicLocalVariable = 25;
two();
/* at this point just one variable “dynamicLocalVariable” exists */
alert(dynamicLocalVariable);
/* this operator displays the current value “25” */
}
function two()
{
var dynamicLocalVariable = 55;
/* at this point two variables “dynamicLocalVariable” exists */
alert(dynamicLocalVariable);
/* this operator displays the current value “55” */
}

14
◦ Variables locales statiques - La valeur de cette Example:
function one()
variable n'est pas détruite et peut être réutilisée {
lorsque la fonction est appelée à nouveau var x = two();
◦ Notez que la fonction «two» renvoie des valeurs alert(x);
/* this operator displays the current value “10” */
différentes pour un même ensemble x = two();
d'arguments. Ces fonctions sont appelées alert(x);
fonctions réactives. Généralement, le test et la /* this operator displays the current value “20” */
}
maintenance de projets ayant de nombreuses function two()
fonctions réactives deviennent une tâche très {
difficile. Pour des raisons pratiques, de var static staticLocalVariable = 0;
nombreux projets logiciels utilisent des données staticLocalVariable = staticLocalVariable + 10;
return(staticLocalVariable);
statiques. }

Notez qu'il n'est toujours pas possible d'attribuer une valeur à la variable statique
locale à l'intérieur d'une fonction depuis l'extérieur.

15
Variables globales statiques Example:
function one()
 La valeur d'une telle variable n'est {
jamais détruite et peut être réutilisée var global globalLocalVariable = 0;
two();
par des opérateurs impératifs dans alert(globalLocalVariable);
n'importe quelle fonction /* this operator displays the current value “10” */
two();
 Les variables globales statiques
alert(globalLocalVariable);
définies dans n'importe quelle /* this operator displays the current value “20” */
fonction ne sont créées qu'une seule }
function two()
fois lorsque l'ensemble du système {
logiciel est lancé. globalLocalVariable = globalLocalVariable + 10;
}

Ici, la fonction « two" démontre également un comportement "réactif". Maintenir et

tester des projets fortement basés sur des variables globales devient encore plus
difficile que dans le cas de variables statiques locales. Néanmoins, pour des raisons
pratiques, de nombreux paradigmes de développement logiciel utilisent de telles
variables statiques globales.

16
Avantages du paradigme procédural:
 Réutilisabilité - réutiliser un module approprié, sans avoir à coder l'algorithme à partir de zéro
 Spécialisation - se concentrer sur l'écriture d'un meilleur module possible (fonction) pour une
tâche particulière tandis que d'autres s'occupent d'autres domaines
 Évolutivité - possibilité de remplacer le code dans la fonction, à condition que l'interface reste la
même - aucune modification ne devrait être nécessaire dans le reste de l'application.

Les modules procéduraux ont de sérieuses limitations:

 Pour commencer, rien n'empêche un autre programmeur de se mêler du code d'un module,
peut-être pour mieux l'adapter aux besoins d'une application particulière.
 Il n'y a également rien pour empêcher le code dans la fonction d'utiliser des variables globales,
annulant ainsi les avantages d'une interface unique fournissant un point d'entrée unique.

De toute évidence, le paradigme est le mieux adapté au modèle en cascade du

développement logiciel.

17
 Un système logiciel particulier est considéré en termes de modules et
de données circulant entre eux en commençant par une vue de haut
niveau.
 Dans ce cas, la méthodologie de conception logicielle peut être classée
comme une conception modulaire descendante (point de vue de la
conception fonctionnelle).

18
 Modularité
◦ Les modules sont utilisés pour décrire une décomposition fonctionnelle du système
◦ Un module contient
 instructions exécutables
 structures de données
 autres modules
◦ Caractéristiques du module
 un nom
 peut être compilé séparément
 peut être utilisé dans un programme ou par d'autres modules
◦ La conception du système détermine généralement ce qui entre dans un module
 Cohésion
◦ Fonction unique clairement définie
◦ Description du moment et de la manière d'utilisation
◦ Modules à couplage lâche (les modules implémentent des fonctionnalités, mais pas des parties d'autres modules)

19
 Boîtes noires (masquage d'informations)
◦ chaque module est une boîte noire
◦ chaque module a un ensemble d'entrées connues et un ensemble de sorties prévisibles
◦ le fonctionnement interne du module est inconnu de l'utilisateur
◦ peut être réutilisable
 La conception préliminaire et détaillée spécifie les modules pour exécuter les fonctions dans
les diagrammes de flux de données (DFD).
◦ La conception préliminaire traite principalement des organigrammes
◦ Arborescence hiérarchique
 Modules - boîtes rectangulaires
 Les relations d'appel sont indiquées par des flèches
 Les flèches sont étiquetées avec les données circulantes entre les modules

20
Conception de modules
 Titre
 ID(entificateur) de module - à partir des organigrammes
 But
 Méthode - algorithme
 Utilisation - qui l'appelle
 Références externes - autres modules appelés
 Séquence d'appel - descriptions des paramètres
 Assertion d'entrée
 Assertion de sortie
 Variables locales
 Auteurs
 Remarques

21
Document de conception préliminaire
 Page de Couverture

 Table des matières

 Description de la conception

 Diagrammes de structure du logiciel

 Dictionnaire de données

 Conceptions de modules

 En-têtes de module

 Conception de structures de données majeures

 Revues de conception (Examen de tout ou partie de la conception du logiciel pour trouver des anomalies de conception)

 Présentation de la conception détaillée

 Sélectionner un algorithme pour chaque module

 Affiner les structures de données

 Produire un document de conception détaillée

22
 Codage (pour chaque module)
◦ Code source
◦ Documentation
 L'intégration
◦ Décidez dans quel ordre les modules seront assemblés
◦ Assembler et tester l'intégration des modules
◦ Après l'assemblage final, effectuez un test du système
Remarque: le codage et les tests sont souvent effectués en parallèle

23
 Types de tests
◦ Tests unitaires
◦ Tests d'intégration
◦ Tests d'acceptation (UAT)

Remarques de clôture
 le paradigme est le mieux adapté au modèle en cascade du développement
logiciel. La mise en œuvre des exigences de changement et surtout le prototypage
rapide sont les points faibles du paradigme de programmation.

24