Qu’il s’agisse du dé­ve­lop­pe­ment d’une ap­pli­ca­tion, de la pro­gram­ma­tion de machines ou du dé­ve­lop­pe­ment d’un logiciel d’en­tre­prise, avant d’écrire la première ligne de code, le dé­ve­lop­peur doit choisir le langage de pro­gram­ma­tion qu’il souhaite utiliser. La gamme des langages de pro­gram­ma­tion est très variée. Cela dit, ces langages peuvent tous être classés en fonction des deux pa­ra­digmes de pro­gram­ma­tion de base : la pro­gram­ma­tion im­pé­ra­tive et la pro­gram­ma­tion dé­cla­ra­tive. Ces deux approches pré­sen­tent des avantages et des in­con­vé­nients.

Quelles sont les ca­rac­té­ris­tiques du paradigme de pro­gram­ma­tion im­pé­ra­tive ? De quelles lacunes les dé­ve­lop­peurs doivent-ils tenir compte ? Le présent article rassemble les réponses aux prin­ci­pales questions liées au paradigme impératif.

Qu’est-ce que la pro­gram­ma­tion im­pé­ra­tive ?

La pro­gram­ma­tion im­pé­ra­tive (du latin imperare = ordonner) est le paradigme de pro­gram­ma­tion le plus ancien. Ce paradigme définit un programme comme une séquence clai­re­ment définie d’ins­truc­tions in­for­ma­tiques.

Le code source des langages im­pé­ra­tifs énonce donc des séquences d’ordres, dé­ter­mi­nant quand l’or­di­na­teur doit exécuter quelle action pour atteindre le résultat souhaité. Les valeurs utilisées dans les variables sont alors trans­for­mées en durée d’exécution du programme. Pour piloter les ordres, des struc­tures de contrôle, telles que des boucles ou em­bran­che­ments, sont intégrées au code.

Le paradigme de pro­gram­ma­tion im­pé­ra­tive est très concret et fonc­tionne en étroite col­la­bo­ra­tion avec le système. Le code est aisément com­pré­hen­sible, mais l’écriture de nom­breuses lignes de code source est né­ces­saire pour décrire ce que les langages de pro­gram­ma­tion dé­cla­ra­tive ob­tien­nent en quelques mots.

Les langages de pro­gram­ma­tion im­pé­ra­tive les plus connus :

  • Fortran
  • Java
  • Pascal
  • ALGOL
  • C
  • C#
  • C++
  • Assembler
  • BASIC
  • COBOL
  • Python
  • Ruby

Les dif­fé­rents langages de pro­gram­ma­tion im­pé­ra­tive peuvent encore être sub­di­vi­sés en trois autres styles de pro­gram­ma­tion se­con­daires : le style de pro­gram­ma­tion structuré, pro­cé­du­ral et modulaire.

Le style de pro­gram­ma­tion structuré étend le principe impératif de base à des struc­tures de contrôle concrètes : séquences, sélection et itération (ré­pé­ti­tion). La maîtrise ou l’évitement complet des ins­truc­tions de saut, qui rendent le code impératif inu­ti­le­ment compliqué, se font en arrière-plan.

L’approche pro­cé­du­rale divise la tâche à exécuter en plusieurs sous-tâches, que le code doit alors décrire sé­pa­ré­ment. Les blocs de pro­gram­ma­tion ainsi créés peuvent ensuite être réu­ti­li­sés au sein d’autres pro­grammes. Le modèle de pro­gram­ma­tion modulaire va encore plus loin en concevant, dé­ve­lop­pant et testant les dif­fé­rents com­po­sants du programme in­dé­pen­dam­ment les uns des autres. Ce n’est qu’à la fin que la com­bi­nai­son des dif­fé­rents modules forme le logiciel pro­pre­ment dit.

Image: Aperçu de la systématisation des programmations déclarative et impérative
La pro­gram­ma­tion im­pé­ra­tive est l’un des deux prin­ci­paux pa­ra­digmes de pro­gram­ma­tion de l’in­for­ma­tique.

Com­pa­rai­son entre les pro­gram­ma­tions dé­cla­ra­tive et im­pé­ra­tive

Un élément fon­da­men­tal distingue le paradigme de pro­gram­ma­tion im­pé­ra­tive du paradigme de pro­gram­ma­tion dé­cla­ra­tive. En bref : la pro­gram­ma­tion im­pé­ra­tive se concentre sur le DÉ­ROU­LE­MENT, la pro­gram­ma­tion dé­cla­ra­tive sur l’OBJECTIF.

Qu’est-ce que cela signifie ? Le paradigme de pro­gram­ma­tion im­pé­ra­tive est rédigé sous la forme d’un mode d’emploi étape par étape (dé­rou­le­ment) à suivre par l’or­di­na­teur. Il décrit ex­pli­ci­te­ment la séquence d’étapes à exécuter pour parvenir à la solution souhaitée. La pro­gram­ma­tion dé­cla­ra­tive, à l’inverse, décrit di­rec­te­ment le résultat final souhaité (objectif). On en trouve un exemple parfait dans nos cuisines : les langages im­pé­ra­tifs énoncent des recettes, les langages dé­cla­ra­tifs four­nis­sent des photos du plat fini.

Avec les langages dé­cla­ra­tifs, le code source reste très abstrait quant à la procédure concrète à suivre. Pour arriver à la solution, on utilise un al­go­rithme re­cher­chant et ap­pli­quant au­to­ma­ti­que­ment les méthodes ap­pro­priées. Cette procédure a de nombreux avantages : non seulement l’écriture des pro­grammes est beaucoup plus rapide, mais en plus, les ap­pli­ca­tions peuvent ensuite être fa­ci­le­ment op­ti­mi­sées. Lorsqu’une nouvelle méthode est mise au point, les ins­truc­tions abs­traites du code source per­met­tent à l’al­go­rithme d’y avoir fa­ci­le­ment recours.

Exemple de pro­gram­ma­tion im­pé­ra­tive

Le paradigme de pro­gram­ma­tion im­pé­ra­tive se distingue par sa forme de mode d’emploi, qui nécessite gé­né­ra­le­ment de nom­breuses lignes de code pour exprimer ce que le style dé­cla­ra­tif peut décrire en quelques mots. Dans l’exemple suivant, nous cherchons à obtenir une liste de prénoms :

Pro­gram­ma­tion im­pé­ra­tive (PHP)

$Listeparticipants = [1 => 'Pierre', 2 => 'Paul', 3 => 'Sarah'];
$prénom = [];
foreach ($Listeparticipants as $id => $nom) {
    $prénom[] = $nom;
}

Pro­gram­ma­tion dé­cla­ra­tive (PHP)

$prénom = array_values($Listeparticipants);

Avantages et in­con­vé­nients du paradigme de pro­gram­ma­tion im­pé­ra­tive

De nos jours, de nombreux langages de pro­gram­ma­tion se fondent sur le paradigme de pro­gram­ma­tion im­pé­ra­tive.

Cela tient, d’une part, au fait que cette approche cor­res­pond au mode de pro­gram­ma­tion initial. De l’autre, au fait que le paradigme impératif présente des avantages pratiques par rapport aux autres modèles.

Com­pa­ra­ti­ve­ment, ces langages sont faciles à apprendre dans la mesure où le code se lit comme un mode d’emploi, étape par étape. En ce sens, au cours de leur formation pro­fes­sion­nelle, les pro­gram­meurs com­men­cent gé­né­ra­le­ment leur ap­pren­tis­sage par un langage impératif.

La bonne li­si­bi­lité est un facteur dé­ter­mi­nant au quotidien : la main­te­nance et l’op­ti­mi­sa­tion des ap­pli­ca­tions ne doivent pas dépendre d’une seule personne, mais pouvoir être fa­ci­le­ment réalisées par divers col­la­bo­ra­teurs, même lorsqu’ils n’ont pas écrit eux-mêmes le code.

In­con­vé­nient de la pro­gram­ma­tion pro­cé­du­rale : lorsqu’il s’agit de résoudre des problèmes plus complexes, le code prend très ra­pi­de­ment de l’ampleur. Bien qu’il reste lisible, il perd en clarté du fait de son volume.

Dans la mesure où son exécution n’est pas clai­re­ment séparée de la pro­gram­ma­tion, comme dans le cas du style dé­cla­ra­tif, des effets se­con­daires in­dé­si­rables ou des erreurs peuvent survenir en cas de re­ma­nie­ments ul­té­rieurs. Il est également plus difficile d’insérer des ex­ten­sions dans du code purement impératif, bien à l’inverse du paradigme dé­cla­ra­tif, au sein duquel des méthodes per­met­tent d’en rajouter de manière séparée.

Avantages In­con­vé­nients
Bien lisible Le code devient très ra­pi­de­ment vo­lu­mi­neux et perd en clarté
Com­pa­ra­ti­ve­ment facile à apprendre Risque d’erreurs supérieur lors de retouches
Modèle de pensée aisément com­pré­hen­sible pour les débutants (étapes de ré­so­lu­tion) Les opé­ra­tions de main­te­nance bloquent le dé­ve­lop­pe­ment d’ap­pli­ca­tions, car la pro­gram­ma­tion est étroi­te­ment liée au système
Permet de tenir compte des ca­rac­té­ris­tiques de cas d’ap­pli­ca­tion spéciaux Op­ti­mi­sa­tions et ex­ten­sions plus dif­fi­ciles

Au jour le jour, on utilise souvent des com­bi­nai­sons de ces pa­ra­digmes, car les styles de pro­gram­ma­tion im­pé­ra­tive et dé­cla­ra­tive com­por­tent tous deux des avantages et des in­con­vé­nients. De plus en plus, le style de pro­gram­ma­tion dé­cla­ra­tive, complété par des méthodes im­pé­ra­tives, s’impose toutefois.

Aller au menu principal