Paradigme (programmation)

Les langages de programmation sont regroupés par paradigmes de la même manière que les machines peuvent être regroupées en fonction de leur utilisation.

Quelques langues s'inscrivent dans un seul paradigme principal, tel que :

• Smalltalk (orienté objet)
• Assemblée (impérative, mais non structurée ou orientée vers l'objet)
• Haskell (fonctionnelle)
• Prologue (logique)

La plupart des langues, cependant, sont dans plus d'un paradigme. Certaines de celles qui se distinguent par le fait d'en avoir plus d'une le sont :

• Scala (orienté objet, fonctionnel, parallèle)
• Visual Basic (piloté par les événements, orienté objet)
• Common Lisp (procédural, fonctionnel, orienté objet, méta)
• Schéma (fonctionnel, procédural, méta)
• Perl (fonctionnel, procédural, méta, orienté objet, événementiel)
• Python (fonctionnel, orienté objet, procédural)
• Ruby (fonctionnel, orienté objet, procédural)
• Langage Wolfram (fonctionnel, procédural, généralement déclaratif)
• Oz (logique, fonctionnel, impératif, orienté objet)
• F# (fonctionnel, impératif, orienté objet, méta)

Il n'est pas toujours bon d'avoir plus de paradigmes. Une fois, le fait d'avoir moins de paradigmes peut être une bonne chose, c'est lorsqu'il y a un langage qui n'est que fonctionnel. Une fonction dans l'une de ces langues fonctionne parfois moins bien (comme le fait de ne passer en revue que les parties d'un groupe de choses dont elle a réellement besoin) que si la langue était également procédurale.

De nombreux paradigmes de programmation sont aussi bien connus pour les choses qu'ils ne laissent pas faire que pour celles qu'ils laissent faire. Les langages fonctionnels en sont un exemple. Lorsqu'un langage fonctionnel est uniquement ou principalement fonctionnel, il ne permet généralement pas d'effets secondaires. La programmation structurée est un autre cas de figure : elle est différente des langages impératifs normaux parce qu'elle ne permet pas aux programmeurs d'utiliser des "déclarations goto" (déclarations indiquant au programme de passer à une étape antérieure). Pour cette raison, entre autres, les gens pensent parfois que les nouveaux paradigmes ne permettent pas assez de choses. Il est parfois acceptable que l'ordinateur ne laisse pas les gens faire des choses, cependant : cela peut aider les gens à éviter des problèmes avec leur code, et laisser l'ordinateur faire des suppositions pour qu'il puisse exécuter le code plus rapidement, ou même vérifier le code pour des problèmes avant que le code ne s'exécute !

Certaines personnes qui étudient les langages de programmation n'aiment pas que les paradigmes soient utilisés pour regrouper les langages de programmation, comme Harper et Krishnamurthi. Ces personnes disent que beaucoup de langages de programmation ne peuvent pas être simplement regroupés en paradigmes parce que les langages empruntent des choses et des idées à de nombreux paradigmes.

De nouveaux paradigmes ont été créés au fil du temps, et les gens les ont soulignés soit à l'époque, soit en regardant en arrière. L'un des premiers paradigmes qui a été reconnu comme une nouvelle façon de programmer a été la programmation structurée des années 1960. L'idée d'un "paradigme de programmation" remonte à 1978, si ce n'est plus, lorsque Robert W. Floyd l'a utilisée en enseignant. Le mot "paradigme" tel que Robert le concevait a été utilisé pour la première fois par Thomas Kuhn dans son livre, The Structure of Scientific Revolutions (1962).

Code machine

Le paradigme de programmation le plus bas (le plus proche de la façon dont l'ordinateur aime comprendre les choses) et le plus ancien est le code machine, un paradigme impératif. Les directions du code machine ne sont qu'un ensemble de nombres dans un certain ordre. Le langage assembleur est un peu moins bas niveau (et un peu moins ancien). Dans le langage assembleur, les directions de l'ordinateur reçoivent des mnémoniques (noms plus faciles à retenir), et les adresses de mémoire (directions pour trouver une information dans l'ordinateur) peuvent recevoir des noms. On les appelle parfois langues de première et de deuxième génération.

Dans les années 1960, les langages d'assemblage ont été améliorés par l'ajout de nouvelles choses comme la COPIE de bibliothèque, les macros (des morceaux de code "spécial" qui ont été transformés en code normal avant que le programme ne commence à fonctionner), les procédures d'exécution (des ensembles de directions données à un nom et enregistrées pour plus tard), et les variables (des éléments donnés à un nom et enregistrés pour plus tard) de l'extérieur du programme. Cela permet d'utiliser du code dans plus d'un projet et de ne pas avoir à se soucier des problèmes spécifiques au matériel (problèmes qui n'arrivent qu'à un seul type d'ordinateur) grâce à des commandes (noms pour les instructions) comme READ/WRITE/GET/PUT.

L'assemblage était, et est parfois encore, utilisé dans des systèmes où il est important que le code soit rapide, et il est également beaucoup utilisé dans les systèmes embarqués car il permet à l'utilisateur d'avoir un contrôle exact de ce que fait la machine.

Langues de procédure

À la toute fin des années 1960, les gens ont commencé à inventer des langues de procédure. Ces langages de troisième génération (les premiers de ce que nous appelons aujourd'hui les langages de haut niveau) comportaient des mots en rapport avec ce qu'ils essayaient de résoudre. Par exemple,

• COmmon Business Oriented Language (COBOL) - utilise des mots comme fichier, déplacer et copier.
• TRADUCTION DE FORMULE (FORTRAN) - utilise des mots et des symboles mathématiques ( formes utilisées dans l'écriture et la frappe). Elle a été développée principalement pour les sciences et l'ingénierie.
• ALGOrithmic Language (ALGOL) - conçu pour écrire des algorithmes (ensembles d'étapes indiquant à l'ordinateur ce qu'il doit faire). Il utilise des mots et des symboles mathématiques, tout comme FORTRAN.
• Le langage de programmation 1 (PL/I) - était censé être utile à tous.
• Beginners All purpose Symbolic Instruction Code (BASIC) - fait pour aider les débutants à programmer.
• C - un langage de programmation destiné à faire beaucoup de choses. Dennis Ritchie y a travaillé de 1969 à 1973 aux AT&T Bell Labs.

Programmation axée sur les objectifs

Après avoir commencé à utiliser des langages procéduraux, de nombreuses personnes ont inventé des langages de programmation orientés objet. Dans ces langages, les données et leurs "méthodes" (façons de manipuler les données) sont mises dans un "objet". Certains programmeurs, comme Richard Stallman, ne sont pas d'accord avec le fait que les langages orientés objet sont meilleurs pour expliquer des idées à un ordinateur que les langages procéduraux.

Parce que la programmation orientée objet est un paradigme, et non un langage, les gens ont créé des langages d'assemblage orientés objet comme le HLA (High Level Assembly).

Les paradigmes déclaratifs

En même temps, certains font des langages de programmation déclaratifs. Un langage bien connu pour être déclaratif est le SQL (un langage permettant d'ajouter et de supprimer des choses dans les tables).