Langages et paradigmes de programmation

Une ligne comme x = a + b désigne un calcul sans mentionner de registre du processeur. L’abstraction rend cela possible : un langage masque les détails de niveau inférieur pour que la personne qui programme puisse se concentrer sur le travail que le programme doit accomplir.

Ce que le processeur exécute

Le code machine se compose d’instructions codées sous forme de nombres binaires. L’architecture du jeu d’instructions d’un processeur définit ses instructions et leur encodage. x86-64 est courant dans les PC et les serveurs ; ARM est courant dans les téléphones, les tablettes et de nombreux ordinateurs portables. Le code construit pour une architecture doit être traduit ou émulé pour fonctionner sur une autre.

L’hexadécimal permet d’afficher les octets des instructions de façon plus courte. Sur x86-64, B8 01 00 00 00 place 1 dans le registre EAX. Les octets 01 D8 ajoutent la valeur d’EBX à EAX. Les registres sont de petits emplacements de stockage à l’intérieur du processeur. Chaque instruction effectue une petite action, comme déplacer des données, additionner, comparer ou effectuer un saut. Le cycle de lecture-décodage-exécution exécute ces instructions.

Des noms pour les mêmes petites actions

Le langage d’assemblage remplace les octets des instructions par des noms lisibles appelés mnémoniques. Les deux instructions x86-64 peuvent s’écrire :

mov eax, 1
add eax, ebx

Un assembleur convertit le langage d’assemblage en code machine. Une ligne d’instruction ordinaire produit normalement une instruction machine. Les noms de registres et les instructions restent propres à une architecture du jeu d’instructions : utiliser des mots au lieu d’octets ne rend donc pas le langage d’assemblage portable.

Décrire un problème en moins de lignes

Un langage de haut niveau fournit des variables, des expressions, des conditions, des boucles et des fonctions. Python, C, Java et JavaScript permettent de décrire des opérations sans sélectionner de registres. Une instruction nécessite généralement plusieurs instructions machine. Une traduction simplifiée de x = a + b effectuerait les étapes suivantes :

1. Charger la valeur de a dans un registre.
2. Charger la valeur de b dans un autre registre.
3. Additionner les valeurs des registres.
4. Stocker le résultat pour x.

Un compilateur réel peut combiner ou réorganiser ces étapes tout en conservant le comportement requis.

Le code source de haut niveau est plus facile à lire, à modifier et à vérifier. Un code source C portable peut être compilé une première fois pour un système x86-64, puis pour un système ARM. Chaque version construite nécessite tout de même une prise en charge adaptée du système d’exploitation et des bibliothèques. La portabilité du code source ne rend pas un exécutable natif universel.

Pourquoi les niveaux inférieurs restent utiles

Le langage d’assemblage reste utile dans le code de démarrage, certaines routines des systèmes d’exploitation et des pilotes, les petits systèmes embarqués et l’analyse de sécurité des programmes dont le code source n’est pas disponible. Pour le code applicatif courant, les compilateurs modernes produisent généralement du code machine dont les performances sont comparables à celles du langage d’assemblage écrit à la main.

Le passage vers des niveaux plus élevés s’est fait progressivement. Le langage d’assemblage s’est répandu à la fin des années 1940 et au début des années 1950. Le système A-0 de Grace Hopper, en 1952, a contribué à faire progresser la traduction automatique. IBM a publié FORTRAN en 1957 ; COBOL a suivi en 1959 et Lisp est apparu vers 1958-1960. « Haut niveau » désigne l’éloignement des détails du matériel, et non la difficulté d’apprentissage du langage.

Un compilateur traduit le code source en code cible. La cible peut être du code machine natif ou une forme intermédiaire comme le bytecode. La compilation anticipée a lieu avant l’exécution du programme ; la compilation à la volée a lieu pendant son exécution.

Du texte aux instructions

Pour une construction anticipée, plusieurs étapes transforment un fichier source en instructions :

1. L’analyse lexicale découpe le texte en unités lexicales : des éléments porteurs de sens comme les noms, les opérateurs et les nombres.
2. L’analyse syntaxique vérifie la grammaire et construit une structure qui montre comment les éléments s’assemblent.
3. L’analyse sémantique vérifie les règles liées au sens, notamment les déclarations et les combinaisons de types autorisées.
4. L’optimisation trouve une façon plus efficace d’effectuer le travail demandé.
5. La génération de code produit les instructions cibles.

Considère l’instruction C total = price * 3;. Ses six unités lexicales sont total, =, price, *, 3 et ;. Les noms sont des identifiants, 3 est un littéral entier et le point-virgule termine l’instruction. L’analyse syntaxique indique que la multiplication fait partie de l’affectation : calculer price * 3, puis stocker sa valeur dans total.

Ces étapes ont des rôles différents. Une suite d’unités lexicales correctement écrites peut tout de même enfreindre la grammaire. Une instruction grammaticalement correcte peut tout de même employer un type de manière incorrecte. Trouver les unités lexicales ne suffit pas à établir qu’un programme est valide.

Effectuer le même travail à moindre coût

Supposons que le code source contienne seconds_per_day = 60 * 60 * 24. Les facteurs sont des constantes, donc le compilateur peut multiplier 60 par 60 pour obtenir 3 600, puis multiplier par 24 pour obtenir 86 400 pendant la construction. Il peut placer la valeur finale dans le résultat produit au lieu de répéter la multiplication à l’exécution. C’est le repliement des constantes.

Une optimisation doit préserver le comportement exigé par le langage. Elle ne peut pas remplacer un calcul par un autre plus rapide qui donnerait des résultats différents de ceux requis. L’objectif est de réduire le travail, le temps ou la mémoire nécessaires tout en conservant le sens du programme.

Assembler les éléments

Les grands programmes sont généralement construits à partir de nombreux fichiers. Un compilateur peut produire un fichier objet pour chaque fichier source. Un fichier objet contient du code traduit qui peut encore nécessiter des liens avec d’autres codes. Un éditeur de liens réunit les éléments et résout les appels aux routines de bibliothèques, comme les fonctions d’affichage ou de calcul.

L’exécutable obtenu est construit pour une plateforme cible, notamment une architecture du jeu d’instructions et des conventions de système d’exploitation. L’utilisateur n’a pas besoin du compilateur anticipé pour l’exécuter. Des bibliothèques partagées ou des composants d’exécution peuvent toutefois rester nécessaires.

Comprendre ce que prouve une construction réussie

En Java, int count = "five"; échoue à une vérification de type avant l’exécution. Du texte ne peut pas initialiser cette variable entière. Le programme doit réussir les vérifications requises à la compilation avant qu’une version exécutable soit disponible.

D’autres défauts subsistent après la compilation. Une division par un zéro saisi par l’utilisateur dépend des données d’exécution. Un programme censé effectuer une soustraction mais qui effectue une addition peut s’exécuter et renvoyer une valeur incorrecte. La compilation vérifie les règles du langage ; les tests doivent aussi vérifier que le résultat correspond à la tâche prévue.

Un programme n’a pas nécessairement besoin de devenir un exécutable natif avant qu’un utilisateur le lance. Un interpréteur exécute le programme par l’intermédiaire d’un autre programme en cours d’exécution. De nombreuses implémentations combinent interprétation et compilation ; la question utile est donc de savoir comment le système considéré exécute le code.

Exécuter au moyen d’un interpréteur

Un interpréteur doit être disponible chaque fois qu’il exécute le programme. Une REPL interactive répète quatre actions : lire une entrée, l’évaluer, afficher un résultat et recommencer pour l’entrée suivante. Elle fournit un retour rapide lorsqu’on essaie de petites expressions.

Interpréter ne signifie pas nécessairement lire le code source brut une ligne à la fois. CPython, l’implémentation standard de Python, compile d’abord un fichier en bytecode. Une machine virtuelle logicielle exécute ensuite ces instructions internes. Le bytecode appartient à cet environnement d’exécution ; il ne s’agit pas du jeu d’instructions natif du processeur.

Pourquoi certaines erreurs apparaissent plus tôt

Compare deux fichiers Python. Celui-ci a une syntaxe valide :

print("start")
x = 10
print(x + "5")

Il affiche « start », associe x à 10, puis déclenche TypeError. L’addition de cet entier à une chaîne de caractères échoue uniquement lorsque l’expression est exécutée. Une opération similaire dans une branche non parcourue peut passer inaperçue jusqu’à l’exécution de cette branche.

Supprime maintenant la parenthèse fermante de la dernière ligne. CPython ne peut pas compiler le fichier, car sa syntaxe est incomplète. Il signale une erreur de syntaxe avant l’exécution de toute instruction du fichier, donc « start » n’est pas affiché. La vérification syntaxique du fichier entier et la vérification à l’exécution d’une opération exécutée ont lieu à des moments différents.

Partager le bytecode, spécialiser pendant l’exécution

Java illustre une approche hybride courante. javac Hello.java produit Hello.class, qui contient du bytecode. java Hello lance une machine virtuelle Java compatible. Différentes implémentations de cette machine virtuelle permettent à ce bytecode de s’exécuter sur différentes familles de processeurs. Le bytecode est portable entre environnements d’exécution compatibles ; chaque environnement doit lui-même fonctionner sur sa plateforme hôte. C# cible de la même façon un langage intermédiaire utilisé par .NET.

Un compilateur à la volée produit du code machine pendant l’exécution du programme. L’environnement d’exécution HotSpot de Java commence généralement par interpréter le code et compile les méthodes fréquemment utilisées. Les moteurs JavaScript des navigateurs combinent aussi des techniques d’exécution, dont la compilation à la volée. Compiler les parties très sollicitées peut améliorer la vitesse sur la durée, mais utilise du temps et de la mémoire pendant l’exécution.

Une boucle qui additionne un milliard de valeurs s’exécute généralement beaucoup plus vite en C compilé que dans CPython : CPython effectue le travail d’interprétation et vérifie les types autour de nombreuses opérations. Pour un script qui renomme 20 fichiers, l’effort de développement peut compter bien davantage que cette différence. Mesure la charge de travail avant de te servir de la désignation d’un langage pour prévoir sa vitesse.

Compilé et interprété décrivent des choix d’implémentation. CPython utilise l’interprétation du bytecode ; PyPy utilise des techniques de compilation à la volée. Un langage peut avoir plusieurs implémentations, et une implémentation peut utiliser plusieurs méthodes d’exécution.

La syntaxe fixe les règles qui déterminent si le texte d’un programme est valide. La sémantique donne son sens à ce texte. Un programme peut respecter toutes les règles de grammaire et tout de même calculer un résultat incorrect : vérifier son apparence n’est donc que la première étape de sa lecture.

Reconnaître les éléments et la grammaire

Les unités lexicales comprennent les mots-clés comme if, les identifiants comme total, les littéraux comme 3 ou "hello", les opérateurs comme + et ==, et la ponctuation. Une grammaire décrit comment ces éléments peuvent former des expressions et des instructions.

Python exige des deux-points après if x > 3: et utilise l’indentation pour marquer les instructions contrôlées par cette condition. C, Java et JavaScript utilisent des accolades pour les blocs ; C et Java exigent aussi des points-virgules après de nombreuses instructions. Dans ces langages, l’indentation aide le lecteur humain, mais ne détermine pas le bloc.

Des syntaxes différentes peuvent exprimer une action similaire. Ces instructions affichent un message de salutation :

print("hello")

printf("hello\n");

System.out.println("hello");

La séquence d’échappement C \n ajoute un saut de ligne. Connaître l’idée de l’affichage aide à apprendre la façon dont chaque langage l’exprime.

Les mêmes symboles peuvent avoir des sens différents

L’apparence familière d’un symbole ne détermine pas son sens d’un langage à l’autre.

L’ordre d’évaluation compte aussi. La priorité fait que la multiplication et la division sont effectuées avant l’addition. Avec a = 4 et b = 6, average = a + b / 2 divise d’abord 6 par 2, puis ajoute 4, ce qui produit 7,0. Les parenthèses dans average = (a + b) / 2 font effectuer la somme en premier et donnent 5,0.

Distinguer les erreurs

Une erreur de syntaxe enfreint la grammaire, comme des deux-points manquants en Python. Une erreur d’exécution se produit lors d’une opération exécutée, comme une division par zéro en Python. Une erreur de logique laisse l’exécution se dérouler, mais donne une réponse non voulue, comme dans le calcul incorrect de la moyenne.

Certaines expressions valides sautent volontairement une opération. En Python, x != 0 and 10 / x > 2 utilise l’évaluation en court-circuit. Lorsque x vaut zéro, la première condition est fausse, donc la partie droite n’est pas évaluée et aucune division n’a lieu. Inverser ces conditions supprimerait cette protection. Python écrit and, or et not ; C, Java et JavaScript utilisent &&, || et !.

L’affectation et la comparaison constituent une autre distinction importante. = stocke une valeur ; == teste l’égalité. C autorise if (x = 5) : cette instruction affecte 5 et traite cette valeur non nulle comme vraie. Python rejette if x = 5: comme une syntaxe invalide. La même erreur peut donc être détectée à une étape différente selon le langage.

Un court programme est plus facile à comprendre lorsque tu suis une instruction exécutée à la fois. Garde les valeurs actuelles visibles au lieu de passer directement de la première ligne à un résultat supposé.

Expressions et affectations

Une expression produit une valeur : price * 3, x > 10 et len(name) en sont des exemples. Une instruction effectue une action, comme affecter une valeur ou contrôler un bloc. Dans total = price * 3, l’expression de droite est évaluée avant que son résultat soit affecté à total.

Une variable est un nom qui fait référence à une valeur. L’affectation donne au nom sa valeur actuelle ; elle n’affirme pas, comme une équation mathématique, que les deux membres ont toujours été égaux. Si count contient 4, count = count + 1 lit d’abord 4, ajoute 1 et associe count à 5.

Suivre la prochaine instruction exécutée

Trois structures organisent le déroulement du programme :

• La séquence exécute les instructions dans l’ordre.
• La structure conditionnelle utilise une condition pour choisir un chemin, par exemple avec if et else.
• L’itération répète un bloc au moyen d’une boucle for ou while.

Le théorème de la programmation structurée, associé à Böhm et Jacopini en 1966, montre que ces structures peuvent exprimer n’importe quel algorithme. Une boucle for parcourt généralement les éléments d’une collection. Une boucle while se répète tant que sa condition reste vraie.

Considère cette boucle Python :

total = 0
for n in [3, 8, 5]:
    total = total + n

L’affectation indentée s’exécute une fois pour chaque élément. Un tableau de suivi d’exécution indique l’état après chaque mise à jour :

Chaque nouveau total utilise le précédent. Réinitialiser total à l’intérieur de la boucle produirait un calcul différent, car les additions précédentes seraient perdues.

Entrer dans une fonction et en sortir

Une fonction regroupe une tâche sous un nom. Un paramètre est un nom dans la définition ; un argument est une valeur fournie par un appel :

def area(width, height):
    return width * height

result = area(3, 4)

L’appel associe width à 3 et height à 4. La multiplication produit 12 et return le transmet à l’appelant. L’exécution reprend à l’affectation, donc result reçoit 12. Ces noms décrivent une tâche qui peut être réutilisée avec d’autres arguments.

Un nom a une portée

La portée détermine où un nom peut être utilisé. Les noms créés dans une fonction sont normalement locaux à cet appel. Un nom défini au niveau principal est global à son module. Des appels distincts ont des associations locales distinctes, même lorsqu’ils utilisent des noms identiques.

count = 7

def reset():
    count = 0

reset()
print(count)

Ce code affiche 7. L’affectation dans reset crée une variable locale count ; elle ne remplace pas l’association globale. Une fonction peut plutôt renvoyer un résultat et laisser l’appelant l’affecter.

La portée et la durée de vie répondent à des questions différentes. Un nom local n’est pas accessible au code extérieur simplement parce que l’objet auquel il faisait référence existe encore. Les objets renvoyés peuvent rester en vie, et une fonction imbriquée renvoyée peut conserver l’accès aux variables de l’appel qui l’englobe ; cet environnement conservé fait partie d’une fermeture lexicale.

Un type de données définit les valeurs possibles et les opérations qu’elles permettent. Un entier permet les opérations arithmétiques sur les nombres entiers ; un booléen représente vrai ou faux. Les chaînes de caractères, les listes, les enregistrements et les objets combinent ou organisent d’autres valeurs. Les types déterminent aussi la façon dont les valeurs sont représentées en mémoire, même si la taille d’une valeur peut dépendre de cette valeur et de l’implémentation.

Quand les types sont-ils vérifiés ?

En Python, count = 5 suivi de count = "five" est valide. Le nom fait désormais référence à une chaîne de caractères. L’évaluation de count + 1 déclenche alors TypeError. Le typage dynamique donne des types définis aux valeurs ; il ne supprime pas les types.

Le typage statique n’exige pas une indication de type visible sur chaque variable. L’inférence de types permet à un compilateur de déduire un type à partir du code environnant. Kotlin déduit un entier pour val n = 5, et Rust peut déduire un entier pour let n = 5;. Les annotations de type facultatives de Python sont différentes : des outils distincts comme mypy peuvent les vérifier, mais l’exécution ordinaire de Python ne les impose pas.

Quand les valeurs sont-elles converties ?

Le moment de la vérification et la rigueur des conversions sont deux questions distinctes. Python rejette "3" + 4 ; la conversion explicite dans int("3") + 4 donne 7. JavaScript applique différentes règles de conversion automatique selon les opérateurs :

• "3" + 4 donne la chaîne "34".
• "3" * 4 donne le nombre 12.
• "3" - 4 donne le nombre -1.

La conversion automatique est appelée conversion implicite. Les termes typage « fort » et « faible » sont des façons informelles de parler de la rigueur des conversions, et non d’autres noms pour le typage statique et dynamique. Python est dynamique et strict pour l’addition de types différents ci-dessus ; C est statique et autorise tout de même de nombreuses conversions numériques implicites.

La fonction input() de Python renvoie une chaîne de caractères. Si une personne saisit « 30 », le résultat est toujours de type str. age + 1 échoue, tandis que int(age) + 1 donne 31 lorsque age contient ce texte. Ce qui apparaît à l’écran ne suffit pas à déterminer le type.

La représentation des nombres a des limites

Un entier signé sur 32 bits représente les valeurs de −2 147 483 648 à 2 147 483 647. Le type int de Java reboucle de la valeur maximale à la valeur minimale lorsqu’on ajoute 1. En C, le dépassement de capacité d’un entier signé est un comportement indéfini : il ne faut donc pas supposer que le même rebouclage se produit. Les entiers Python grandissent autant que la mémoire le permet : 2 ** 100 vaut exactement 1 267 650 600 228 229 401 496 703 205 376.

Les nombres à virgule flottante représentent la plupart des fractions décimales de manière approximative en binaire. En Python et JavaScript, 0.1 + 0.2 produit 0.30000000000000004. Comparer directement ce résultat à 0.3 donne faux.

Lorsqu’un calcul permet une petite erreur, compare les valeurs à l’aide d’une tolérance choisie pour la tâche, par exemple abs(a - b) < 1e-9. Une tolérance absolue aussi petite ne convient qu’à certaines échelles. Pour une comptabilité décimale exacte, utilise des nombres entiers dans la plus petite unité ou un type décimal adapté. Modifier la comparaison ne peut pas rendre exacte une représentation approximative.

La mémoire principale stocke les données d’un programme pendant son exécution. Chaque octet possède une adresse. Les langages fournissent des noms pour permettre aux personnes qui programment de manipuler des valeurs sans écrire d’adresses brutes à chaque opération.

Les appels utilisent des blocs d’activation ; les objets ont une durée de vie

En C, un int occupe généralement 4 octets et &x obtient l’adresse de x. Les langages de plus haut niveau masquent souvent les adresses derrière des références. Il faut distinguer l’association qui nomme un objet de l’objet lui-même.

La pile d’appels assure le suivi des appels de fonctions actifs. Chaque appel possède un bloc d’activation contenant des informations comme les paramètres, les associations locales et l’endroit où l’exécution doit reprendre après le retour. Si main appelle area(3, 4), un bloc pour area est ajouté au-dessus de celui de l’appelant. La fonction calcule 12, se termine et son bloc est retiré. Pour les appels imbriqués ordinaires, l’appel le plus récent se termine en premier.

La récursivité ajoute un appel pour chaque niveau non terminé. Si les appels continuent de s’accumuler, l’espace disponible dans la pile peut s’épuiser. Python déclenche normalement RecursionError après environ 1 000 appels imbriqués, la limite dépendant de ses paramètres. Une condition d’arrêt doit être atteinte pour qu’un calcul récursif fini se termine.

Le tas contient les objets alloués dynamiquement, comme une liste qui grandit ou un objet qui survit à la fonction qui l’a créé. L’allocation mémoire réserve de l’espace de stockage. Une liste renvoyée peut rester sur le tas après la fin de l’appel qui l’a créée.

Copier une référence partage un objet

Une référence désigne un objet. Un pointeur en C ou C++ représente explicitement une adresse utilisée pour accéder à des données. Copier une référence copie l’accès à l’objet, et non toutes les données de l’objet.

a = [1, 2]
b = a
b.append(3)

Après la première ligne, il existe une liste. La deuxième ligne lui associe un autre nom. La dernière ligne modifie cette liste : a et b montrent donc toutes deux [1, 2, 3]. Ce partage est appelé aliasing. Utiliser b = a.copy() créerait une liste externe distincte ; pour cette liste d’entiers, ajouter un élément à la nouvelle liste laisserait a inchangée.

Compare l’affectation et la mutation :

x = 5
y = x
y = y + 1

L’entier 5 est immuable. L’addition produit 6, et seul y est associé à une nouvelle valeur. x fait toujours référence à 5. Les nombres, chaînes de caractères et tuples de Python sont immuables ; les listes et les dictionnaires sont mutables. Le contenu fixe d’un tuple peut comprendre une référence à une liste mutable : l’immuabilité du conteneur externe ne fige donc pas tous les objets qu’il contient.

Appliquer les mêmes règles aux arguments

Lorsque Python transmet une liste à une fonction, le paramètre fait référence au même objet. Appeler items.append(4) dans la fonction modifie cette liste. L’affectation items = [] associe uniquement le nom du paramètre local à une nouvelle liste. Le nom de l’appelant reste associé à l’objet d’origine.

C transmet les valeurs des arguments par valeur. Pour permettre à une fonction de modifier une variable de l’appelant par son adresse, transmets un pointeur vers cette variable. Dans chaque langage, pose-toi deux questions distinctes pendant le suivi : « À quel objet ce nom fait-il référence ? » et « Cette opération modifie-t-elle cet objet ou associe-t-elle un nom à autre chose ? »

La mémoire allouée doit finir par devenir réutilisable. La difficulté consiste à libérer les données après leur dernière utilisation tout en conservant chaque objet dont le programme a encore besoin. Les langages confient cette responsabilité à la personne qui programme, à un système d’exécution ou à des règles de possession vérifiées par le compilateur.

Gestion manuelle et erreurs possibles

En C, malloc(n) demande n octets et renvoie, en cas de succès, un pointeur vers le bloc. free(p) libère un bloc obtenu par allocation. La personne qui programme doit l’utiliser au bon moment et exactement une fois. C++ prend aussi en charge la gestion manuelle, même si ses outils standards peuvent automatiser la libération grâce aux durées de vie des objets.

Plusieurs erreurs ont des causes différentes :

Un pointeur qui continue de faire référence à un espace libéré est un pointeur pendant. L’espace peut être réutilisé pour autre chose : y accéder peut donc corrompre des données ou faire planter le programme.

Pour un tableau C int scores[10], les positions valides vont de 0 à 9. Écrire dans scores[10] dépasse les bornes du tableau, et C ne fournit aucune vérification automatique de ces bornes. Python déclenche IndexError lorsque l’indice 10 est utilisé sur une liste de dix éléments, ce qui empêche cet accès d’écraser la mémoire adjacente.

Suivre l’accessibilité ou compter les références

Un ramasse-miettes par traçage part de racines actives, comme les références en cours d’utilisation, suit les liens entre les objets et peut récupérer les objets inaccessibles. Java, C#, Go et JavaScript utilisent des approches par traçage. Le ramassage demande du travail et de la mémoire à l’exécution ; selon le ramasse-miettes, il peut entraîner des pauses.

Le comptage de références suit les références à un objet. Pour une nouvelle liste Python, la séquence simplifiée est la suivante : a = [1, 2] fournit une référence ; b = a en fournit une deuxième ; del a en supprime une ; b = None supprime l’autre. CPython récupère normalement cette liste ordinaire lorsque son compteur atteint zéro.

Un groupe d’objets peut maintenir les compteurs de chacun au-dessus de zéro même lorsqu’aucune partie active du programme ne peut atteindre le groupe. C’est un cycle de références. CPython complète le comptage de références par un ramassage des cycles. Le comptage de références et le traçage sont deux techniques de gestion automatique de la mémoire.

Vérifier la possession avant l’exécution

Rust donne à chaque valeur un propriétaire et vérifie les règles d’emprunt des références. Lorsque la possession prend fin, le code de nettoyage généré libère la valeur. Le Rust sûr rejette les utilisations de références susceptibles de survivre à la validité de leur cible, sans nécessiter de ramasse-miettes par traçage. Swift utilise un comptage automatique de références inséré par le compilateur.

La sûreté mémoire ne concerne pas seulement les plantages. Microsoft a indiqué en 2019 qu’environ 70 % des vulnérabilités auxquelles l’entreprise attribuait chaque année des CVE concernaient la sûreté mémoire ; Chromium a indiqué une proportion comparable de bogues graves en 2020. En décembre 2023, la CISA, la NSA, le FBI et des partenaires internationaux ont encouragé les éditeurs de logiciels à prévoir une transition vers des langages à sûreté mémoire.

La récupération automatique conserve tout de même les objets accessibles. Une liste globale qui ne cesse de grandir peut garder tous les anciens enregistrements en vie même après que l’application a fini de les utiliser. Un ramasse-miettes ne peut pas décider que ces enregistrements accessibles sont devenus inutiles à la tâche ; le programme doit cesser de les conserver.

Un paradigme de programmation est une façon d’organiser le code et de penser le calcul. En programmation impérative, un programme donne des commandes qui modifient son état : les valeurs actuellement contenues dans les variables et les objets.

Rendre les changements d’état visibles

Un total cumulé est un calcul impératif simple :

total = 0
for n in [3, 8, 5]:
    total = total + n

L’état initial est total = 0. L’ajout de 3 le fait passer à 3. L’ajout de 8 le fait passer à 11. L’ajout de 5 le fait passer à 16. Chaque affectation utilise l’état laissé par l’étape précédente : l’ordre fait donc partie de la méthode.

Ce style correspond aux modifications successives que le processeur apporte aux registres et à la mémoire. Il convient aussi aux algorithmes qui mettent volontairement à jour une collection en place, comme une routine de tri qui échange des éléments.

Donner des noms aux tâches

La programmation procédurale organise le code impératif en fonctions ou procédures. Un programme de rapport peut appeler read_scores(), average(scores) et print_report(avg). Ces noms permettent de voir la tâche globale sans suivre immédiatement chaque ligne interne. Chaque procédure peut être comprise et testée séparément.

C, Pascal, Fortran et COBOL sont des langages procéduraux classiques. Python prend aussi en charge ce style : un script peut utiliser des fonctions nommées sans définir de classes.

La programmation structurée organise le déroulement du programme à l’aide de séquences, de structures conditionnelles, de boucles et d’appels de procédures. Elle évite les sauts arbitraires qui rendent difficile la prévision de la prochaine instruction exécutée. La lettre d’Edsger Dijkstra de 1968, « Go To Statement Considered Harmful », a contribué à populariser cette approche. Les sorties contrôlées comme break, continue et return restent utiles : elles permettent de quitter une itération donnée, une boucle ou une fonction.

Les effets peuvent dépasser la valeur de retour

Un effet de bord modifie quelque chose au-delà du résultat renvoyé par une fonction. Afficher du texte, enregistrer un fichier, envoyer un message réseau et modifier des données partagées sont des effets de bord. Les programmes ont besoin de ces actions pour interagir avec le monde.

Des problèmes apparaissent lorsque des parties du code sans lien apparent modifient le même état sans le signaler. Supposons que apply_discount() réduise une variable globale price de 10 % et que add_shipping() ajoute 5. En partant de 100, appliquer d’abord la remise donne 90, puis l’ajout des frais de livraison donne 95. Ajouter d’abord les frais donne 105, puis la remise donne 94,5. Les deux procédures effectuent correctement leurs propres étapes, mais le résultat combiné dépend de leur ordre.

Transmettre des valeurs et renvoyer de nouveaux résultats peut rendre cet ordre visible :

price = add_shipping(apply_discount(100))

L’appel intérieur s’exécute en premier : remise, puis frais de livraison. Une imbrication différente exprime une règle différente. Une circulation claire des données aide à voir si la remise doit aussi s’appliquer aux frais de livraison.

Le code impératif reste courant dans les méthodes d’objets et les gestionnaires d’événements modernes. Choisir une conception globale orientée objet ou fonctionnelle n’empêche pas une petite partie d’utiliser des commandes directes lorsque ces étapes rendent l’algorithme clair.

La programmation orientée objet modélise un programme sous la forme d’objets qui coopèrent. Chaque objet associe des données aux opérations sur ces données. Un compte peut contenir son titulaire et son solde tout en proposant des opérations de dépôt et de retrait.

Distinguer le modèle de ses instances

Une classe définit les attributs et les méthodes que ses objets fournissent. Un objet, ou une instance, est un élément particulier de cette classe. BankAccount est le modèle ; le compte d’Ana avec 150 et celui de Ben avec 40 sont des instances distinctes. Leurs soldes peuvent changer indépendamment.

Un attribut stocke des données associées à un objet. Une méthode est une opération appelée par l’intermédiaire d’un objet, comme acct.deposit(50). Dans une méthode d’instance Python, self fait référence à l’objet qui reçoit l’appel.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

L’appel BankAccount("Ana", 100) construit une nouvelle instance. Sa méthode __init__ initialise les données de l’instance. Un constructeur est le processus de préparation d’un nouvel objet ; Python sépare la création de cette étape d’initialisation. L’appel acct.deposit(50) sur ce compte fait passer son solde de 100 à 150.

Placer la règle au point de mise à jour

L’encapsulation réunit les données et les opérations qui garantissent le respect de leurs règles. Supposons qu’un compte ne doive jamais avoir un solde négatif. La méthode de retrait vérifie la modification proposée avant de l’effectuer :

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

Cette méthode appartient à BankAccount. À partir d’un solde de 150, withdraw(200) déclenche une erreur et laisse 150. withdraw(30) réussit et laisse 120. L’appel qui échoue n’effectue pas d’abord la soustraction pour découvrir ensuite le problème ; la vérification a lieu avant la mise à jour.

Les autres parties du code doivent utiliser ces méthodes au lieu d’affecter un solde sans vérification. Java et C# peuvent limiter l’accès direct avec private. En Python, le trait de soulignement initial dans _balance signale par convention un détail interne ; il n’impose pas la confidentialité.

Le masquage de l’information va plus loin : les appelants dépendent des opérations proposées par une classe sans avoir besoin de connaître sa représentation interne. Le solde pourrait être stocké différemment par la suite, tandis que les opérations publiques de dépôt et de retrait conserveraient leur sens.

Laisser le problème suggérer les responsabilités

Un système de bibliothèque comporte des livres, des adhérents et des prêts. Ces noms suggèrent des classes ou des attributs possibles ; des actions comme emprunter et renouveler suggèrent des méthodes. Choisis une responsabilité claire pour chaque classe. Une classe de compte qui envoie aussi tous les courriels et met en forme tous les rapports devient plus difficile à modifier, car des tâches sans lien sont mélangées.

Les classes et les objets sont apparus dans Simula 67 en 1967 ; Smalltalk a contribué à diffuser cette approche dans les années 1970. Java, C#, C++ et Python prennent en charge la programmation orientée objet, mais l’utilisation de l’un de ces langages n’impose pas d’organiser chaque programme en classes. La question de conception utile est de savoir quelles données et quelles règles vont ensemble.

Les objets ont souvent besoin de partager des opérations tout en différant dans les détails. L’héritage, le polymorphisme et la composition résolvent différentes parties de ce problème de conception.

Spécialiser un type d’objet existant

L’héritage définit une sous-classe à partir d’une superclasse. En Python, class SavingsAccount(BankAccount): donne à la classe spécialisée accès au comportement hérité du compte. Elle peut ajouter add_interest(rate) : un solde de 1 000 auquel on ajoute 2 % d’intérêts devient 1 020.

La relation recherchée est est un. Un compte d’épargne reste un compte bancaire et doit respecter les règles attendues des comptes bancaires. Réutiliser quelques lignes n’est pas une raison suffisante pour affirmer qu’un type d’objet en est un autre.

Une sous-classe peut redéfinir une méthode avec sa propre implémentation. Supposons qu’un compte courant facture des frais de 1 pour chaque retrait réussi. Avec un solde de 100, retirer 30 coûte 31 et laisse 69. Pour préserver la règle du compte, la méthode doit vérifier le retrait plus les frais avant de modifier le solde. Si ce coût total dépasse le solde, elle refuse toute l’opération.

Faire fonctionner un même appel avec différents objets

Le polymorphisme permet à une même opération de fonctionner sur différents types d’objets. Un cercle et un rectangle peuvent tous deux fournir area() :

for shape in shapes:
    print(shape.area())

La boucle n’a pas besoin d’un if pour chaque classe de forme. Chaque objet fournit sa propre implémentation. Le choix de cette implémentation pendant l’exécution est la liaison dynamique.

Pour Circle(2), l’aire est d’environ 12,57 unités carrées. Pour Rectangle(3, 4), elle est de 12 unités carrées. Leur aire totale est d’environ 24,57 unités carrées. Une classe Triangle ajoutée plus tard peut rejoindre la collection en fournissant une opération area() compatible ; la boucle elle-même n’a pas besoin d’une branche supplémentaire.

Une interface indique les opérations qu’un type doit proposer. L’interface Java interface Shape { double area(); } impose aux classes qui l’implémentent de fournir la méthode de calcul de l’aire. Une classe abstraite peut fournir une partie de l’implémentation commune tout en laissant d’autres méthodes aux sous-classes. Python utilise souvent le typage canard : un objet peut fonctionner dans la boucle s’il fournit l’opération requise, même sans superclasse commune.

Contenir un composant au lieu de le devenir

La composition stocke d’autres objets comme composants. Une voiture possède un moteur et des roues. Elle peut appeler la méthode start() de son moteur sans hériter de Engine.

Les longues chaînes d’héritage peuvent propager les effets d’une modification de superclasse à de nombreuses classes. Une sous-classe qui doit désactiver un comportement hérité peut révéler une relation « est un » inadaptée. La composition rend souvent ces dépendances moins importantes et plus claires.

Les quatre piliers habituellement cités de la programmation orientée objet s’articulent ici : l’encapsulation protège les données au moyen d’opérations, l’abstraction masque les détails de l’implémentation, l’héritage spécialise un type et le polymorphisme permet à un appelant d’utiliser une opération partagée entre plusieurs implémentations.

La programmation fonctionnelle construit des résultats en combinant des fonctions. Son principe central consiste à produire de nouvelles valeurs à partir des entrées tout en limitant les mutations partagées. Lisp a introduit des idées fonctionnelles largement utilisées vers 1958 ; Haskell, Erlang, Clojure, F# et OCaml développent ces idées de différentes façons.

Savoir ce qui rend une fonction pure

Une fonction pure donne le même résultat pour les mêmes arguments et n’a aucun effet de bord. def with_tax(price): return price * 1.2 illustre cette idée : with_tax(50) donne 60,0. Une fonction qui ajoute aussi un élément à une liste globale ou affiche un message a un effet au-delà de sa valeur de retour. Un résultat qui dépend de l’heure actuelle dépend lui aussi de plus que des arguments.

Un appel pur peut être remplacé par sa valeur de retour sans modifier le comportement du programme. Cette propriété est la transparence référentielle. Elle rend les tests isolés simples et permet à des appels indépendants de s’exécuter en parallèle sans chercher à mettre à jour le même état partagé.

L’immuabilité maintient une valeur existante inchangée. [n + 1 for n in nums] crée une nouvelle liste et laisse nums intacte. Un programme peut toujours représenter des informations qui changent en produisant de nouvelles versions ; il n’a pas besoin d’écraser l’ancienne version.

Transmettre un comportement comme une donnée

Les fonctions sont de première classe lorsqu’elles peuvent être affectées à des noms, transmises comme arguments et renvoyées comme valeurs. Une fonction d’ordre supérieur reçoit une fonction ou en renvoie une. Une expression lambda est une expression de fonction sans nom, comme lambda n: n * n.

Trois opérations d’ordre supérieur courantes forment une chaîne de traitement :

• filter conserve les éléments qui satisfont un test.
• map transforme chaque élément restant.
• reduce combine les éléments en un seul résultat à l’aide d’un accumulateur.

Pour calculer la somme des carrés des nombres pairs de 1 à 6, le filtrage laisse 2, 4 et 6 ; leur élévation au carré donne 4, 16 et 36 ; leur somme donne 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Ici, % 2 == 0 teste si un nombre est pair, et range(1, 7) fournit les nombres de 1 à 6. Haskell exprime le même calcul par sum (map (^2) (filter even [1..6])).

Avec reduce importé de functools en Python, reduce(lambda acc, n: acc + n, [3, 8, 5], 0) combine 0 et 3 pour obtenir 3, puis ce résultat et 8 pour obtenir 11, puis ce résultat et 5 pour obtenir 16. La chaîne décrit des transformations sans boucle autour qui mettrait à jour un total partagé.

Conserver un environnement ou appeler la fonction sur un problème plus petit

def multiplier(k): return lambda x: k * x renvoie une fonction qui conserve l’accès à k. Ainsi, multiplier(3)(10) renvoie 30 même après la fin de l’appel extérieur. La fonction renvoyée et l’environnement conservé forment une fermeture lexicale.

La récursivité consiste pour une fonction à s’appeler elle-même sur un problème plus petit. La factorielle renvoie 1 lorsque n == 0 ; sinon, elle renvoie n * factorial(n - 1). Pour 5, les produits donnent 120. Un calcul fini nécessite un cas de base accessible. En Python, les appels imbriqués non résolus finissent par déclencher RecursionError ; les langages qui prennent correctement en charge les appels terminaux peuvent réutiliser l’espace de pile pour les appels en position finale.

Utiliser des fonctions ne suffit pas à rendre le code fonctionnel : les fonctions procédurales peuvent modifier l’état. Les programmes fonctionnels réels lisent toujours des entrées et produisent des sorties, en gardant généralement les effets près des frontières du programme et les calculs centraux purs.

La programmation déclarative décrit le résultat voulu tout en laissant les étapes d’exécution à un moteur de langage. Le code fonctionnel est généralement regroupé sous cette idée générale, aux côtés des langages de requête et de la programmation logique.

Lire une requête comme une demande

Une base de données relationnelle stocke les données dans des tables. Supposons que students contienne les lignes de noms et de notes Ana 92, Ben 75, Chen 80 et Dara 64 :

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM indique la table, WHERE donne la condition, SELECT choisit le champ renvoyé et ORDER BY demande l’ordre alphabétique. Ana et Chen satisfont la condition, y compris avec la note de Chen, exactement égale à 80. Le résultat contient leurs noms dans cet ordre.

Un programme impératif créerait une liste de résultats, parcourrait les lignes, testerait chaque note, ajouterait les noms répondant au critère et trierait la liste. SQL indique à la base de données le résultat attendu sans écrire cette boucle.

Un optimiseur de requêtes choisit un plan d’exécution. Il peut parcourir la table ou utiliser un index disponible, une structure de recherche qui peut accélérer les recherches adaptées. De nombreux index utilisent des structures triées ; d’autres utilisent des organisations différentes. L’ajout d’un index peut modifier le plan sans modifier la requête. Davantage de données implique toujours du travail : déclarer le résultat ne garantit pas que chaque requête soit peu coûteuse.

Demander ce qui découle de faits et de règles

La programmation logique décrit des faits et des relations, puis recherche les valeurs qui répondent à une question. En Prolog :

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

La règle signifie que X est un grand-parent de Z lorsqu’il existe un Y pour lequel les deux relations de parenté sont vérifiées. La requête ?- grandparent(tom, Who). trouve Who = ann : Tom est le parent de Bob et Bob est le parent d’Ann. Les noms commençant par une majuscule représentent des variables ; les noms en minuscules désignent des personnes particulières.

Reconnaître les outils déclaratifs autour de toi

Une formule de tableur =SUM(B2:B5) énonce une dépendance. Le tableur la recalcule lorsque les cellules concernées changent. L’expression régulière [0-9]{3}-[0-9]{4} décrit trois chiffres, un trait d’union et quatre chiffres, comme dans « 555-0199 ». Un moteur de recherche de correspondances textuelles effectue la recherche.

CSS définit l’apparence avec une règle comme h1 { color: navy; } ; HTML balise la structure d’une page. Ce sont des notations déclaratives, généralement classées comme langages de style et de balisage. Leur rôle diffère de celui d’un langage généraliste qui peut exprimer une grande variété de calculs.

Le code déclaratif peut rester proche de l’énoncé d’un problème et laisser un moteur améliorer sa méthode. Il donne aussi à la personne qui programme moins de contrôle direct sur chaque étape, ce qui peut rendre un plan lent plus difficile à diagnostiquer. Des instructions concrètes s’exécutent toujours en dessous : « déclaratif » décrit la façon dont la personne exprime la tâche, et non un processeur qui fonctionne sans étapes.

Un paradigme change la façon d’exprimer une solution, pas la réponse numérique qu’une solution correcte doit produire. Considère des commandes de montants [120, 45, 300, 80] : trouve le total des montants strictement supérieurs à 100.

Suivre les changements d’état

La version impérative rend visibles la boucle et l’accumulateur :

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

Le premier montant fait passer total à 120. Le deuxième le laisse inchangé. Le troisième le fait passer à 420, et le quatrième le laisse à cette valeur. Le programme rend visibles l’ordre du test et celui de la mise à jour.

Transformer une collection

Une expression Python compacte de style fonctionnel est sum(a for a in amounts if a > 100). Elle sélectionne 120 et 300 et les combine pour obtenir 420. Une autre version est sum(filter(lambda a: a > 100, amounts)). Ici, le prédicat décrit quels éléments sont retenus et sum combine les valeurs sélectionnées.

Une expression génératrice ou un appel à filter utilise les fonctionnalités multiparadigmes de Python ; sa présence ne rend pas pures toutes les parties de l’application qui l’entourent.

Associer les règles aux objets

Dans une conception orientée objet, un objet Order stocke un amount et propose is_large(), qui renvoie self.amount > 100. Un objet OrderBook contient des objets représentant les commandes et propose large_total(). Cette méthode peut parcourir les commandes, demander à chacune si elle satisfait le critère et additionner les montants correspondants.

Le total reste 420. La différence tient à la répartition des responsabilités : la règle définissant une commande importante appartient à Order, et le travail portant sur la collection appartient à OrderBook. D’autres fonctionnalités peuvent réutiliser la règle sans copier son test de seuil.

Interroger la base de données

Si les données se trouvent déjà dans une base de données relationnelle, SQL peut demander le total :

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

La base de données choisit le plan de récupération et d’agrégation. La requête ne demande pas à un appelant de parcourir chaque ligne ou de conserver un accumulateur local.

Combiner les styles lorsqu’ils sont utiles

Python prend en charge les techniques procédurales, orientées objet et fonctionnelles. JavaScript fournit des objets, des fonctions de première classe et des fermetures lexicales. C++, C#, Kotlin, Scala, Swift et Rust mélangent aussi les styles. Java est fortement associé à la programmation orientée objet, mais prend en charge les expressions lambda depuis Java 8 en 2014 ; Haskell est purement fonctionnel.

Une application web peut utiliser des classes pour les utilisateurs et les commandes, des transformations fonctionnelles pour les données des rapports, des mises à jour impératives dans les méthodes et SQL pour les requêtes de base de données. Ces choix interviennent à différentes couches.

La programmation événementielle ajoute une autre idée d’organisation : enregistrer un gestionnaire qui s’exécute lorsqu’un événement arrive. En JavaScript, button.addEventListener("click", showMenu) transmet showMenu comme une valeur de fonction. Un clic ultérieur l’appelle. Le gestionnaire peut lui-même utiliser des objets, des transformations pures ou des étapes impératives. Son rôle événementiel indique quand il s’exécute, pas le seul style que son corps peut utiliser.

Aucun langage de programmation ne convient mieux que tous les autres à chaque projet. Les langages généralistes sont généralement Turing-complets : avec un temps et une mémoire sans limites, ils peuvent exprimer la même classe de calculs. Dans la pratique, le choix dépend de l’adéquation de la solution à la plateforme, aux ressources, aux outils et aux personnes concernés.

Commencer par ce qui doit fonctionner

La plateforme est souvent une contrainte incontournable. Les navigateurs exécutent JavaScript et peuvent exécuter des modules compilés grâce à WebAssembly. TypeScript ajoute une vérification statique et se compile en JavaScript. Swift est un choix courant pour les applications des plateformes Apple ; Kotlin est recommandé pour Android. SQL est le langage habituel des requêtes relationnelles.

Considère ensuite le domaine et l’écosystème. Python possède des bibliothèques de données et d’apprentissage automatique largement utilisées, comme NumPy et pandas. R se concentre sur les statistiques. C et C++ sont courants dans les systèmes d’exploitation, les moteurs de jeux et le code embarqué. Java et C# sont courants dans les grands systèmes d’entreprise ; Bash est utile pour automatiser les tâches du système d’exploitation.

Ce sont des associations pratiques, pas des domaines réservés. Une bibliothèque adaptée peut économiser bien plus de travail de développement qu’une petite différence de syntaxe entre langages.

Examiner les besoins en ressources et en sûreté

Un microcontrôleur doté de quelques kilo-octets de mémoire vive seulement peut nécessiter un contrôle précis de la mémoire et du surcoût à l’exécution. C, C++ ou Rust peuvent convenir lorsque la cible les prend en charge. Les composants exigeants des jeux ou des bases de données favorisent souvent ces langages eux aussi, mais les moteurs et les budgets de ressources diffèrent : Unity utilise C#, et certaines bases de données utilisent Java ou Go.

Avant de choisir en fonction de la vitesse, trouve le goulot d’étranglement : la partie qui limite les performances. Un programme qui attend principalement une réponse du réseau ne deviendra pas beaucoup plus rapide simplement parce qu’une petite boucle locale est compilée plus efficacement. Mesure un travail représentatif sur la plateforme cible.

La sûreté mémoire réduit les erreurs comme les accès mémoire invalides. Le Rust sûr vérifie les règles de possession à la compilation ; les langages à mémoire gérée comme Java, C#, Go et Python assurent la gestion de la mémoire à l’exécution. Le typage statique détecte de nombreuses opérations incompatibles avant l’exécution, ce qui peut aider dans une grande base de code. Ni la sûreté mémoire ni le typage statique ne prouvent que la logique du programme est correcte.

Inclure le coût de maintenance du résultat

Les connaissances de l’équipe, les personnes disponibles pour le développement, les débogueurs, les outils de test, les bibliothèques, les licences et le code existant influent tous sur la décision. Un langage connu de l’équipe et pris en charge peut réduire les coûts de livraison et de maintenance. Réécrire un système fonctionnel entraîne du travail de migration et des risques, même si le nouveau langage possède des fonctionnalités attrayantes.

Pour un réseau météorologique urbain, les différents composants ont des besoins différents :

Une justification utile relie chaque choix à un besoin : « L’équipe maintient déjà le service Java et ses bibliothèques prennent en charge la nouvelle fonctionnalité. » Un rang dans un classement de popularité ne peut pas fournir ce raisonnement à lui seul. Les enquêtes peuvent indiquer l’existence d’une grande communauté ou d’un vaste vivier de recrutement ; elles n’établissent pas quel langage convient le mieux à une charge de travail particulière.