« Informatique au lycée/Programmation et langages » : différence entre les versions
m Robot : Remplacement de texte automatisé (-\n(==={0,3})(?: *)([^\n=]+)(?: *)\1(?: *)\n +\n\1 \2 \1\n) |
m Robot : remplacement de texte automatisé (-(<|</)source([ \t>]) +\1syntaxhighlight\2) |
||
Ligne 25 : | Ligne 25 : | ||
On distingue aujourd’hui cinq générations de langages. |
On distingue aujourd’hui cinq générations de langages. |
||
La '''première génération''' est le langage machine, ou code machine. On parle aussi de langage natif. Il est composé d'instructions et de données à traiter codées en binaire. C'est le seul langage qu'un ordinateur peut traiter directement. Voici à quoi peut ressembler un programme en langage machine : |
La '''première génération''' est le langage machine, ou code machine. On parle aussi de langage natif. Il est composé d'instructions et de données à traiter codées en binaire. C'est le seul langage qu'un ordinateur peut traiter directement. Voici à quoi peut ressembler un programme en langage machine : |
||
< |
<syntaxhighlight lang="bash"> |
||
A1 01 10 03 06 01 12 A3 01 14 |
A1 01 10 03 06 01 12 A3 01 14 |
||
</syntaxhighlight> |
|||
</source> |
|||
Il s'agit de la représentation hexadécimale d'un programme permettant d'additionner les valeurs de deux cases mémoire et de stocker le résultat dans une troisième case. On voit immédiatement la difficulté d'un tel langage. |
Il s'agit de la représentation hexadécimale d'un programme permettant d'additionner les valeurs de deux cases mémoire et de stocker le résultat dans une troisième case. On voit immédiatement la difficulté d'un tel langage. |
||
Ligne 33 : | Ligne 33 : | ||
La '''deuxième génération''' est le langage assembleur : le code devient lisible et compréhensible par un plus grand nombre d'initiés. Il existe en fait un langage assembleur par type de processeur. |
La '''deuxième génération''' est le langage assembleur : le code devient lisible et compréhensible par un plus grand nombre d'initiés. Il existe en fait un langage assembleur par type de processeur. |
||
Le programme précédent écrit en assembleur donnerait ceci : |
Le programme précédent écrit en assembleur donnerait ceci : |
||
< |
<syntaxhighlight lang="asm"> |
||
MOV AX, [0110] |
MOV AX, [0110] |
||
ADD AX, [0112] |
ADD AX, [0112] |
||
MOV [0114], AX |
MOV [0114], AX |
||
</syntaxhighlight> |
|||
</source> |
|||
Il reste utilisé dans le cadre d'optimisations, mais a été supplanté en popularité par les langages plus accessibles de troisième génération. |
Il reste utilisé dans le cadre d'optimisations, mais a été supplanté en popularité par les langages plus accessibles de troisième génération. |
||
Ligne 47 : | Ligne 47 : | ||
La '''cinquième génération''' de langages sont des langages destinés à résoudre des problèmes à l'aide de contraintes, et non d'algorithmes écrits. Ces langages reposent beaucoup sur la logique et sont particulièrement utilisés en intelligence artificielle. Parmi les plus connus, on trouve [[w:Prolog|Prolog]], dont voici un exemple : |
La '''cinquième génération''' de langages sont des langages destinés à résoudre des problèmes à l'aide de contraintes, et non d'algorithmes écrits. Ces langages reposent beaucoup sur la logique et sont particulièrement utilisés en intelligence artificielle. Parmi les plus connus, on trouve [[w:Prolog|Prolog]], dont voici un exemple : |
||
< |
<syntaxhighlight lang="prolog"> |
||
frère_ou_soeur(X,Y) :- parent(Z,X), parent(Z,Y), X \= Y. |
frère_ou_soeur(X,Y) :- parent(Z,X), parent(Z,Y), X \= Y. |
||
parent(X,Y) :- père(X,Y). |
parent(X,Y) :- père(X,Y). |
||
Ligne 55 : | Ligne 55 : | ||
père(tom, erica). |
père(tom, erica). |
||
père(mike, tom). |
père(mike, tom). |
||
</syntaxhighlight> |
|||
</source> |
|||
Il en résulte que la demande suivante est évaluée comme vraie : |
Il en résulte que la demande suivante est évaluée comme vraie : |
||
< |
<syntaxhighlight lang="prolog"> |
||
?- frère_ou_soeur(sally, erica). |
?- frère_ou_soeur(sally, erica). |
||
oui. |
oui. |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce qui signifie que Sally et Erica sont sœurs. En effet, Sally et Erica ont le même père (Tom). |
Ce qui signifie que Sally et Erica sont sœurs. En effet, Sally et Erica ont le même père (Tom). |
||
Ligne 71 : | Ligne 71 : | ||
==== Ada ==== |
==== Ada ==== |
||
< |
<syntaxhighlight lang="ada"> |
||
with Ada.Text_IO; |
with Ada.Text_IO; |
||
use Ada.Text_IO; |
use Ada.Text_IO; |
||
Ligne 78 : | Ligne 78 : | ||
Put("Hello world!"); |
Put("Hello world!"); |
||
end Bonjour; |
end Bonjour; |
||
</syntaxhighlight> |
|||
</source> |
|||
==== Assembleur X86 sous DOS ==== |
==== Assembleur X86 sous DOS ==== |
||
< |
<syntaxhighlight lang="asm"> |
||
cseg segment |
cseg segment |
||
assume cs:cseg, ds:cseg |
assume cs:cseg, ds:cseg |
||
Ligne 95 : | Ligne 95 : | ||
cseg ends |
cseg ends |
||
end main |
end main |
||
</syntaxhighlight> |
|||
</source> |
|||
==== BASIC ==== |
==== BASIC ==== |
||
< |
<syntaxhighlight lang="basic4gl"> |
||
10 PRINT "Hello world!" |
10 PRINT "Hello world!" |
||
20 END |
20 END |
||
</syntaxhighlight> |
|||
</source> |
|||
==== C ==== |
==== C ==== |
||
< |
<syntaxhighlight lang="c"> |
||
#include <stdio.h> |
#include <stdio.h> |
||
Ligne 110 : | Ligne 110 : | ||
return 0; |
return 0; |
||
} |
} |
||
</syntaxhighlight> |
|||
</source> |
|||
==== C++ ==== |
==== C++ ==== |
||
< |
<syntaxhighlight lang="cpp"> |
||
#include <iostream> |
#include <iostream> |
||
Ligne 120 : | Ligne 120 : | ||
return 0; |
return 0; |
||
} |
} |
||
</syntaxhighlight> |
|||
</source> |
|||
==== FORTRAN 77 ==== |
==== FORTRAN 77 ==== |
||
< |
<syntaxhighlight lang="fortran"> |
||
PROGRAM BONJOUR |
PROGRAM BONJOUR |
||
WRITE (*,*) 'Hello world!' |
WRITE (*,*) 'Hello world!' |
||
END |
END |
||
</syntaxhighlight> |
|||
</source> |
|||
==== Java ==== |
==== Java ==== |
||
< |
<syntaxhighlight lang="java"> |
||
public class HelloWorld { |
public class HelloWorld { |
||
public static void main(String[] args) { |
public static void main(String[] args) { |
||
Ligne 134 : | Ligne 134 : | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</source> |
|||
==== Javascript ==== |
==== Javascript ==== |
||
< |
<syntaxhighlight lang="javascript"> |
||
document.write("Hello world!"); |
document.write("Hello world!"); |
||
</syntaxhighlight> |
|||
</source> |
|||
==== Python 1 et 2 ==== |
==== Python 1 et 2 ==== |
||
< |
<syntaxhighlight lang="python"> |
||
print "Hello world!" |
print "Hello world!" |
||
</syntaxhighlight> |
|||
</source> |
|||
==== Python 3 ==== |
==== Python 3 ==== |
||
< |
<syntaxhighlight lang="python"> |
||
print("Hello world!") |
print("Hello world!") |
||
</syntaxhighlight> |
|||
</source> |
|||
== La machine de Turing == |
== La machine de Turing == |
Version du 13 janvier 2022 à 17:38
Un peu d'histoire
En 1936, la publication de l’article fondateur de la science informatique « On Computable Numbers with an Application to the Entscheidungsproblem », par Alan Mathison Turing, allait donner le coup d'envoi à la création de l'ordinateur programmable. Il y présente sa machine de Turing, le premier calculateur universel programmable, et invente les concepts et les termes de programmation et de programme. En 1948, Konrad Zusee publie un article sur son langage de programmation qu’il a développé entre 1943 et 1945 : le Plankalkül. Zuse le considère comme étant le premier langage de haut niveau. C'est à partir des années 1950 que l’on verra apparaître les premiers langages de programmation modernes. Voici les créateurs des langages les plus utilisés :
- John Backus, inventeur de Fortran (1954)
- John McCarthy, inventeur de LISP (1958)
- Grace Hopper, surnommée « la mère langage COBOL » (1959)
- John George Kemeny, concepteur du BASIC (1963)
- Dennis Ritchie et Ken Thompson, inventeurs du langage C (1972)
- Niklaus Wirth inventeur de Pascal (1970) et Modula-2 (1977)
- Bjarne Stroustrup, développeur de C++ (1985)
- Guido van Rossum, créateur de Python (1991)
- James Gosling et Patrick Naughton, créateurs de Java (1991).
Évolution des langages informatiques
On distingue aujourd’hui cinq générations de langages. La première génération est le langage machine, ou code machine. On parle aussi de langage natif. Il est composé d'instructions et de données à traiter codées en binaire. C'est le seul langage qu'un ordinateur peut traiter directement. Voici à quoi peut ressembler un programme en langage machine :
A1 01 10 03 06 01 12 A3 01 14
Il s'agit de la représentation hexadécimale d'un programme permettant d'additionner les valeurs de deux cases mémoire et de stocker le résultat dans une troisième case. On voit immédiatement la difficulté d'un tel langage.
La deuxième génération est le langage assembleur : le code devient lisible et compréhensible par un plus grand nombre d'initiés. Il existe en fait un langage assembleur par type de processeur. Le programme précédent écrit en assembleur donnerait ceci :
MOV AX, [0110]
ADD AX, [0112]
MOV [0114], AX
Il reste utilisé dans le cadre d'optimisations, mais a été supplanté en popularité par les langages plus accessibles de troisième génération.
La troisième génération utilise une syntaxe proche de l'anglais. Proposés autour de 1960, ces langages ont permis un gain énorme en lisibilité et en productivité. Ils ne dépendent plus du processeur, comme c’était le cas des générations précédentes, mais d'un compilateur spécifique du processeur. L’idée de portabilité des programmes était lancée. La plupart des langages de programmation actuels sont de troisième génération. On trouve dans cette catégorie tous les grands langages : Ada, Algol, Basic, Cobol, Eiffel, Fortran, C, C++, Java, Perl, Pascal, Python, Ruby, ... Cette génération couvre d'ailleurs tant de langages qu'elle est souvent subdivisée en catégories, selon le paradigme particulier des langages.
Les langages de quatrième génération, abrégés L4G, souvent associée à des bases de données, se situent un niveau au-dessus, en intégrant la gestion de l'interface utilisateur et en proposant un langage moins technique, plus proche de la syntaxe naturelle. Ils sont conçus pour un travail spécifique : gestion de base de données (Microsoft Access, SQL), production graphique (Postscript), création d'interface (4D).
La cinquième génération de langages sont des langages destinés à résoudre des problèmes à l'aide de contraintes, et non d'algorithmes écrits. Ces langages reposent beaucoup sur la logique et sont particulièrement utilisés en intelligence artificielle. Parmi les plus connus, on trouve Prolog, dont voici un exemple :
frère_ou_soeur(X,Y) :- parent(Z,X), parent(Z,Y), X \= Y.
parent(X,Y) :- père(X,Y).
parent(X,Y) :- mère(X,Y).
mère(trude, sally).
père(tom, sally).
père(tom, erica).
père(mike, tom).
Il en résulte que la demande suivante est évaluée comme vraie :
?- frère_ou_soeur(sally, erica).
oui.
Ce qui signifie que Sally et Erica sont sœurs. En effet, Sally et Erica ont le même père (Tom).
Quelques langages courants
« Hello world ! »
C'est dans un memorandum interne de Brian Kernighan, Programming in C : A tutorial, écrit en 1974 dans les laboratoires Bell, que l’on trouve la première version d'un mini-programme affichant à l'écran « Hello World! ». Voici comment cela s'écrit dans divers langages :
Ada
with Ada.Text_IO;
use Ada.Text_IO;
procedure Bonjour is
begin -- Bonjour
Put("Hello world!");
end Bonjour;
Assembleur X86 sous DOS
cseg segment
assume cs:cseg, ds:cseg
org 100h
main proc
jmp debut
mess db 'Hello world!$'
debut:
mov dx, offset mess
mov ah, 9
int 21h
ret
main endp
cseg ends
end main
BASIC
10 PRINT "Hello world!"
20 END
C
#include <stdio.h>
int main()/* ou int argc, char *argv[] */
{
printf("Hello world!\n");
return 0;
}
C++
#include <iostream>
int main()
{
std::cout << "Hello world!" << std::endl;
return 0;
}
FORTRAN 77
PROGRAM BONJOUR
WRITE (*,*) 'Hello world!'
END
Java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
Javascript
document.write("Hello world!");
Python 1 et 2
print "Hello world!"
Python 3
print("Hello world!")