Programmation impérative

En informatique, la programmation impérative est un paradigme de programmation qui décrit les opérations en séquences d'instructions exécutées par l'ordinateur pour modifier l'état du programme. Ce type de programmation est le plus répandu parmi l'ensemble des langages de programmation existants, et se différencie de la programmation déclarative (dont la programmation logique ou encore la programmation fonctionnelle sont des sous-ensembles).

Langages impératifs et processeurs

La quasi-totalité des processeurs qui équipent les ordinateurs sont de nature impérative : ils sont faits pour exécuter du code écrit sous forme d'opcodes (pour operation codes), qui sont des instructions élémentaires exécutables par le processeur. L'ensemble des opcodes forme le langage machine spécifique au processeur et à son architecture. L'état du programme à un instant donné est défini par le contenu de la mémoire centrale à cet instant, et le programme lui-même est écrit en style impératif en langage machine, ou le plus souvent dans une traduction lisible par les humains du langage machine, dénommée assembleur.

Les langages de plus haut niveau utilisent des variables et des opérations plus complexes, mais suivent le même paradigme. Les recettes de cuisine et les vérifications de processus industriel sont deux exemples de concepts familiers qui s'apparentent à de la programmation impérative ; de ce point de vue, chaque étape est une instruction, et le monde physique constitue l'état modifiable. Puisque les idées de base de la programmation impérative sont à la fois conceptuellement familières et directement intégrées dans l'architecture des microprocesseurs, la grande majorité des langages de programmation est impérative.

Instructions de la base impérative

La plupart des langages de haut niveau comporte quatre types d'instructions principales :

la séquence d'instructions
l'assignation ou affectation ;
l'instruction conditionnelle ;
la boucle;

et les branchements.

Une séquence d'instructions, (ou bloc d'instruction) désigne le fait de faire exécuter par la machine une instruction, puis une autre, etc, en séquence. Par exemple $\mbox{ouvrirConnexion}; \mbox{envoyerMessage}; \mbox{fermerConnexion};$ est une séquence d'instructions. Cette construction se distingue du fait d'exécuter en parallèle des instructions.
Les instructions d'assignation, en général, effectuent une opération sur l'information en mémoire et y enregistrent le résultat pour un usage ultérieur. Les langages de haut niveau permettent de plus l'évaluation d'expressions complexes qui peuvent consister en une combinaison d'opérations arithmétiques et d'évaluations de fonctions et l'assignation du résultat en mémoire. Par exemple: $x \leftarrow 2 + 3;$ assigne la valeur $2 + 3$ , donc 5, à la variable de nom $x$ .
Les instructions conditionnelles permettent à un bloc d'instructions de n'être exécuté que si une condition prédéterminée est réalisée. Dans le cas contraire, les instructions sont ignorées et la séquence d'exécution continue à partir de l'instruction qui suit immédiatement la fin du bloc. Par exemple $si \; \mbox{connectionOuverte} \; alors \; \mbox{envoyerMessage};$ n'enverra le message que si la connexion est ouverte.
Les instructions de bouclage servent à répéter une suite d'instructions un nombre prédéfini de fois (voir Boucle_for), ou jusqu'à ce qu'une certaine condition soit réalisée. Par exemple $tantque \; \mbox{connexionNonOuverte} \; alors \; \mbox{attendreUnPeu};$ bouclera jusqu'à la connexion soit ouverte.

Il se trouve que ces quatre constructions permettent de faire tous les programmes informatiques possibles, elles permettent de faire un système Turing-complet.

Les branchements sans condition permettent à la séquence d'exécution d'être transférée à un autre endroit du programme. Cela inclut le saut, appelé « goto » (go to, /ɡəʊ tuː/, « aller à ») dans de nombreux langages, et les sous-programmes, ou appels de procédures. Les instructions de bouclage peuvent être vues comme la combinaison d'un branchement conditionnel et d'un saut. Les appels à une fonction ou une procédure (donc un Sous-programme) correspondent à un saut, complété du passage de paramètres, avec un saut en retour.

Historique

Langage machine

Les langages impératifs les plus anciens sont les langages machine des premiers ordinateurs. Dans ces langages, le jeu d'instructions est minimal, ce qui rend la mise en œuvre matérielle plus simple — on maîtrise directement ce qui se passe en mémoire —, mais gêne la création de programmes complexes.

A-0

Le premier compilateur – un programme destiné à vérifier un programme au préalable et à le traduire en langage machine – dénommé A-0, fut écrit en 1951 par Grace Murray Hopper.

FORTRAN

FORTRAN, développé par John Backus chez IBM à partir de 1954, fut le premier langage de programmation capable de réduire les obstacles présentés par le langage machine dans la création de programmes complexes. FORTRAN était un langage compilé, qui autorisait entre autres l'utilisation de variables nommées, d'expressions complexes, et de sous-programmes. Après plusieurs révisions du langage, en 1978 et en 1990, FORTRAN est toujours utilisé dans le milieu scientifique pour la qualité de ses bibliothèques numériques et sa grande rapidité, ce qui en fait le langage informatique ayant eu la plus grande longévité.

Algol

Les deux décennies suivantes virent l'apparition de plusieurs autres langages de haut niveau importants. ALGOL, développé en 1958 par un consortium américano-européen pour concurrencer FORTRAN, qui était un langage propriétaire, fut l'ancêtre de nombreux langages de programmation d'aujourd'hui.

COBOL et BASIC

COBOL (1960) et BASIC (1963) étaient deux tentatives pour rendre la syntaxe plus proche de l'anglais, et donc plus accessible. COBOL était spécifiquement destiné aux applications de gestion, tandis que BASIC avait essentiellement un but éducatif. Sa simplicité et le fait qu'il soit interprété facilitaient grandement la mise au point des programmes, ce qui lui conféra rapidement une grande popularité, malgré la pauvreté de ses constructions. Malheureusement, cette pauvreté même devait mener à une quantité de programmes non structurés et donc difficilement maintenables. Après un article de Edsger Dijkstra dénonçant les ravages de BASIC, la réputation de BASIC comme langage pour l'enseignement de la programmation déclina.

Pascal

Dans les années 1970, le Pascal fut développé par Niklaus Wirth, dans le but d'enseigner la programmation structurée et modulaire. Pascal combinait les meilleures constructions des langages COBOL, FORTRAN et ALGOL dans un ensemble élégant (servi par un grand nombre de types prédéfinis : ensemble, enum, intervalle), qui lui assura un succès durable comme langage d'initiation (en remplacement de BASIC). Par la suite, Niklaus Wirth fut à l'origine de Modula-2, Modula-3, et d'Oberon, les successeurs de Pascal.

En opposition à C, Pascal effectue un contrôle rigoureux des types, des index de tableaux et les chaînes de caractères bénéficient d'une définition bien moins simpliste. Les pointeurs sont également typés (sauf décision explicite du programmeur). Cette rigueur ne pèse en réalité que sur le compilateur, le développeur peut se reposer sur les contrôles effectués à la compilation pour détecter la quasi-totalité des fautes d'inattention ou les confusions dues à un algorithme complexe.

Les rares erreurs passant la compilation sont liées à l'algorithme lui-même, à des pointeurs mal maîtrisés (mais leur typage évite les bugs les plus pernicieux) ; il est habituel pour un programmeur Pascal de voir s'exécuter au premier lancement un programme de complexité supérieure à la moyenne.^{[réf. nécessaire]}

Le débat de la vitesse d'exécution entre le Pascal et le C n'a pas lieu d'être, il suffisait de lever les sécurités du Pascal par les directives de compilation (Turbo Pascal de Borland) pour avoir une vitesse d'exécution comparable à C. Mais le développeur Pascal ne passait que peu de temps en débogage et le code était par nature beaucoup plus maintenable grâce à la rigueur du compilateur.

Cela dit, les légères différences de tolérance à la structuration ou au typage, entre autres, ne remplaceront en aucun cas la qualité du programme. Le temps de débogage sera par définition tout aussi important, dès lors que les conseils de base et la structuration seront imposés par Pascal et considérés comme implicite ou acquis par d'autres.

Pascal s'interface simplement avec un autre langage en déclarant des procédure externes. On peut le lier par exemple avec du C ou de l'assembleur ce qui permet un accès total au fonctionnement interne du système en profitant d'un langage très structuré, richement typé, facilement maintenable.

C

À la même époque, Dennis Ritchie créa le fameux langage C aux laboratoires Bell, pour le développement du système Unix. La puissance du C, permettant grâce aux pointeurs de travailler à un niveau proche de la machine, ainsi qu'un accès complet aux primitives du système, lui assura un succès qui ne s'est jamais démenti depuis.

Une des causes succès du langage C par rapport aux autres langages procéduraux de la même génération vient de son mode de distribution : les universités américaines pouvaient acheter une licence au prix de 300 dollars pour toute l'université et tous ses étudiants. Ce système a formé toute une génération de développeurs — dont Bill Joy grand contributeur de BSD et cofondateur de Sun Microsystems^{[réf. nécessaire]}.

Ada

En 1974, le Département de la Défense des États-Unis cherchait un langage dont le cahier des charges mettait l'accent sur la sûreté d'exécution, pour tous ses besoins futurs. Le choix se porta sur Ada, langage créé par Jean Ichbiah à Honeywell, dont la spécification ne fut complétée qu'en 1983.

Smalltalk

Dans les années 1980, devant les problèmes que posaient la complexité grandissante des programmes, il y eut un rapide gain d'intérêt pour la programmation orientée objet. Smalltalk-80, conçu à l'origine par Alan Kay en 1969, fut présenté en 1980 par le Palo Alto Research Center de la compagnie Xerox (États-Unis).

C++ et Objective C

À partir des concepts objet, Bjarne Stroustrup, chercheur aux Bell Labs, conçut en 1985 une extension orientée objet de C nommée C++, qui gardait la vitesse de C. Parallèlement, une extension à C moins ambitieuse, mais inspirée de Smalltalk avait vu le jour, Objective C. Le succès d'Objective C, notamment utilisé pour le développement sur les stations NeXT et Mac OS X, est resté faible par rapport à C++.

Perl, Tcl, Python, PHP et Java

Dans les décennies 1980 et 1990, de nouveaux langages impératifs interprétés ou semi-interprétés doivent leur succès au développement de scripts pour des pages web dynamiques et les applications client-serveur. On peut citer dans ces catégories Perl (Larry Wall, 1987), Tcl (John Ousterhout, 1988), Python (Guido van Rossum, 1990), PHP (Rasmus Lerdorf, 1994) et Java (Sun Microsystems, 1996).

Langages fonctionnels et langages de programmation logique

Les langages de programmation impératifs doivent être distingués d'autres types de langages, les langages fonctionnels et les langages de programmation logique. Les langages fonctionnels, tels que Haskell ou ML, ne sont pas des suites d'instructions et ne s'appuient pas sur l'idée d'état global, mais au contraire tendent à s'extraire de ce modèle pour se placer à un niveau plus conceptuel (qui a ses fondations dans le lambda-calcul). Les langages de programmation logiques, tels que Prolog, se concentrent sur ce qui doit être calculé, et non comment le calcul doit être effectué.

Annexes

Liens externes

Un synopsis de l'histoire des langages de programmation
Un cours en ligne de l'Université Paris XIII

Portail de la programmation informatique

This article is issued from Wikipédia - version of the Tuesday, September 22, 2015. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.