Diversité et unité des langages de programmation

Introduction

Il existe aujourd'hui des centaines de langages de programmation : Python, C, Java, JavaScript, OCaml, Rust, Haskell, SQL, HTML… Cette profusion peut sembler désordonnée. Elle reflète en réalité l'idée qu'aucun langage n'est universellement adapté : on choisit un langage selon l'usage, la performance, la communauté ou les contraintes du matériel. Pourtant, sous cette diversité, presque tous les langages s'appuient sur les mêmes constructions de base. [PG02]

Apprendre la programmation, ce n'est donc pas apprendre un langage — c'est apprendre à reconnaître ces constructions universelles, et à les retrouver dans n'importe quel langage que vous croiserez plus tard.

Pourquoi tant de langages ?

Un langage de programmation est conçu autour d'un compromis entre plusieurs exigences difficiles à satisfaire toutes en même temps :

Aucun langage ne maximise tout. Python est lisible mais lent à l'exécution. C est rapide mais offre peu de garde-fous. SQL exprime des requêtes sur des bases de données mais ne sert pas à écrire un jeu vidéo.

Les grands paradigmes

Un paradigme est une grande famille de manière de concevoir un programme. Trois paradigmes dominent l'enseignement en NSI :

• Impératif : on décrit une suite d'instructions qui modifient l'état d'une mémoire. C'est le style de Python que vous pratiquez le plus souvent, et celui du langage C.
• Fonctionnel : on décrit le programme comme une composition de fonctions mathématiques sans état mutable. Style natif d'OCaml, Haskell, largement présent en JavaScript moderne.
• Objet : on regroupe données et opérations dans des objets qui s'envoient des messages. Style de Java, C++, et possible en Python.

Python est un langage multi-paradigme : il accepte les trois styles, parfois mélangés. Voici le même programme — calculer la somme des carrés des entiers de $1$ à $5$ — écrit dans les trois styles.

total = 0
for i in range(1, 6):
    total = total + i * i
print(total)  # 55

nombres = range(1, 6)
carres = map(lambda n: n * n, nombres)
total = sum(carres)
print(total)  # 55

class Compteur:
    def __init__(self):
        self.total = 0
    def ajouter_carre(self, n):
        self.total += n * n

c = Compteur()
for i in range(1, 6):
    c.ajouter_carre(i)
print(c.total)  # 55

Le résultat est le même. Le « grain » d'écriture diffère.

Compilation, interprétation, machines virtuelles

Une fois le programme écrit, il faut le transformer en quelque chose que le processeur sait exécuter. Deux grandes approches existent :

• Compilation : un programme spécial, le compilateur, traduit entièrement le code source en code machine une fois pour toutes. On exécute ensuite le résultat compilé. C'est rapide à l'exécution, mais spécifique à un type de processeur. Exemples : C, C++, Rust, Go.
• Interprétation : un interpréteur lit le code source et l'exécute ligne par ligne, sans étape de traduction préalable visible. C'est plus lent à l'exécution mais immédiat à essayer. Exemples : Python, JavaScript (dans un navigateur), Ruby.

Sortie (varie fortement selon votre machine ou votre interpréteur) :

Version de l'interpréteur Python : (3, 12, 0)
Plateforme : linux

Unité sous la diversité

Au-delà des paradigmes et des manières d'exécuter, presque tous les langages généralistes partagent les mêmes briques de construction :

Quand vous découvrirez un nouveau langage, cherchez d'abord ces cinq constructions. Vous serez productif beaucoup plus vite que si vous abordez le langage comme une nouveauté complète.

Pièges courants

Pour aller plus loin

Le langage que vous apprendrez après Python sera plus facile que Python ne l'a été : vous chercherez juste les constructions équivalentes. C'est ce qu'on appelle le transfert pédagogique. C'est l'objectif central de cet item [PG02] du programme.