Aller au contenu
Encyclopédie informatique Édition 2026

Panorama des langages récents

Partie 2 sur 4

Niveau de lecture :

3Des idées communes

Malgré leurs différences, les langages récents partagent un air de famille. Beaucoup de leurs idées viennent de langages universitaires des années 1970 à 1990, comme ML ou Haskell, longtemps restés confidentiels.

  • L’inférence de types : le compilateur déduit le type des variables, ce qui donne la sécurité du typage statique sans la lourdeur des déclarations (voir les variables et les types).
  • Pas de valeur nulle cachée : une valeur qui peut manquer a un type particulier, Option en Rust, String? en Kotlin et en Swift, string | null en TypeScript, et le compilateur oblige à traiter l’absence.
  • Le filtrage par motifs : une instruction, match, when ou switch, compare une valeur à différentes formes et vérifie que tous les cas sont traités.
  • L’immuabilité par défaut : les variables ne changent pas, sauf indication contraire (let mut, var), ce qui rend le code plus prévisible.
  • Les erreurs comme valeurs : Result en Rust, plusieurs valeurs de retour en Go, plutôt que des exceptions invisibles dans la signature des fonctions.
  • Une concurrence plus sûre : goroutines et canaux de Go, coroutines de Kotlin, async et await, acteurs de Swift, vérification des accès partagés en Rust et en Swift.
  • Des outils intégrés : gestionnaire de paquets, outil de mise en forme du code, tests et documentation livrés avec le langage, et aide à la saisie dans tous les éditeurs grâce à un protocole commun, le LSP (Language Server Protocol, « protocole de serveur de langage »).

Ces idées ont tant convaincu que les langages plus anciens les adoptent à leur tour : Java a ajouté les record, le filtrage par motifs et des fils d’exécution légers ; C# a ajouté les types qui peuvent ou non être nuls ; Python a ajouté des annotations de type, le filtrage par motifs et, en 2025, une version sans verrou global, qui exploite enfin pleinement plusieurs cœurs (voir Python). La frontière entre « anciens » et « nouveaux » langages s’estompe.

4Le même problème dans six langages

Pour voir concrètement ces idées communes et ces différences, voici la même fonction écrite dans Python, langage de référence pour beaucoup de débutants, puis dans les cinq grands langages récents : calculer la moyenne d’une liste de notes, en tenant compte du cas où la liste est vide.

# Python
def moyenne(notes: list[float]) -> float | None:
    return sum(notes) / len(notes) if notes else None

// Go
func Moyenne(notes []float64) (float64, bool) {
    if len(notes) == 0 {
        return 0, false
    }
    total := 0.0
    for _, n := range notes {
        total += n
    }
    return total / float64(len(notes)), true
}

// Rust
fn moyenne(notes: &[f64]) -> Option<f64> {
    if notes.is_empty() { return None; }
    Some(notes.iter().sum::<f64>() / notes.len() as f64)
}

// TypeScript
function moyenne(notes: number[]): number | undefined {
    if (notes.length === 0) return undefined;
    return notes.reduce((a, b) => a + b, 0) / notes.length;
}

// Kotlin
fun moyenne(notes: List<Double>): Double? =
    if (notes.isEmpty()) null else notes.average()

// Swift
func moyenne(_ notes: [Double]) -> Double? {
    notes.isEmpty ? nil : notes.reduce(0, +) / Double(notes.count)
}

Plusieurs points communs sautent aux yeux. Dans les six versions, le cas de la liste vide est visible dans la signature de la fonction : Option en Rust, Double? en Kotlin et en Swift, number | undefined en TypeScript, float | None dans les annotations de Python, et une seconde valeur de retour, un booléen, en Go. Celui qui appelle la fonction sait donc qu’il doit traiter ce cas ; dans les langages compilés, il y est même obligé. Les différences sont tout aussi instructives. Go, fidèle à sa philosophie, écrit une boucle explicite, plus longue mais sans surprise. Rust, Go et Swift exigent une conversion explicite du nombre d’éléments, un entier, en nombre à virgule, là où Python, TypeScript et Kotlin la font implicitement : un détail qui évite des erreurs de calcul discrètes. Kotlin, enfin, dispose directement d’une fonction average() dans sa bibliothèque standard.

Aucune version n’est « la meilleure » : chacune reflète des choix de conception, entre concision, explicite et garanties, et chaque langage a ses usages, ses conventions et son style, que l’on apprend en lisant le code des autres. Lire le même programme dans plusieurs langages est d’ailleurs un excellent exercice pour comprendre ce que chacun privilégie.

Pour s’exercer

Exercice 3 : un air de famille

Que font ces trois fragments, en Rust, en Kotlin et en Swift ? Quelle idée commune illustrent-ils ?

// Rust
let n = texte.parse::<i32>().ok().unwrap_or(0);
// Kotlin
val n = texte.toIntOrNull() ?: 0
// Swift
let n = Int(texte) ?? 0
Voir la réponse

Les trois convertissent un texte en entier et utilisent 0 si la conversion échoue. Dans les trois langages, la conversion renvoie une valeur qui peut manquer, Option en Rust, Int? en Kotlin et en Swift, et le programme doit dire explicitement quoi faire en cas d’absence, ici fournir une valeur par défaut. C’est l’idée commune de la « valeur nulle explicite » : en C ou en Java, une conversion ratée produit souvent une valeur arbitraire ou une exception oubliée.

Exercice 4 : par où commencer ?

Un éditeur de logiciel de sécurité possède un produit de 2 millions de lignes de C++. La direction lui demande une feuille de route vers les langages sûrs pour la mémoire. Faut-il tout réécrire en Rust ? Que proposer ?

Voir la réponse

Tout réécrire serait long, coûteux et risqué : on introduirait de nouveaux bogues dans un code éprouvé. L’expérience d’Android montre qu’il suffit d’écrire le nouveau code en langage sûr, les failles se concentrant dans le code récent, et de réécrire en priorité les composants les plus exposés : ceux qui analysent des données venues de l’extérieur, fichiers, paquets réseau, formats complexes. La feuille de route comprend donc : une règle « nouveau code en Rust » ; une liste des composants exposés, réécrits progressivement ; un durcissement du C++ restant, avec des options de compilation et des outils de détection ; et un plan de formation des équipes.

Exercice 5 : un langage très jeune en production ?

Une jeune entreprise veut écrire son service de paiement dans un langage sorti il y a deux ans, encore en version 0.x, parce que ses développeurs l’apprécient. Quels risques identifier ?

Voir la réponse

Instabilité : chaque nouvelle version peut casser le code. Bibliothèques : celles de chiffrement, d’accès aux bases de données ou de connexion aux services de paiement peuvent manquer, être incomplètes ou n’avoir jamais été auditées. Outils : les analyseurs de sécurité et les outils de suivi des failles des dépendances ne prennent peut-être pas le langage en charge. Recrutement : peu de développeurs le connaissent. Pérennité : le projet peut être abandonné. Pour un service de paiement, soumis à des obligations de conformité, ces risques pèsent lourd ; un langage établi, ou un langage récent mais mûr comme Go, Kotlin ou Rust, serait plus raisonnable.

Exercice 6 : anciens langages, idées nouvelles

Citez, pour Java, C# et Python, une idée empruntée aux langages récents ou aux langages universitaires dont ils s’inspirent.

Voir la réponse

Java : les record, des classes de données en une ligne, le filtrage par motifs dans switch, et les fils d’exécution virtuels, très légers, proches des goroutines. C# : les types de référence qui peuvent ou non être nuls, vérifiés à la compilation, et le filtrage par motifs. Python : les annotations de type, vérifiées par des outils externes, le filtrage par motifs avec match, et la version sans verrou global, qui permet l’exécution réellement parallèle de plusieurs fils. Ces évolutions montrent que l’innovation circule dans les deux sens.

Exercice 7 : la division entière

Dans la comparaison de la section 4, pourquoi Rust, Go et Swift obligent-ils à convertir explicitement le nombre d’éléments avant la division ? Que se passerait-il en C avec int total = 25; int n = 2; double m = total / n; ?

Voir la réponse

En C, total / n est une division entre deux entiers, qui donne un entier : 25 / 2 vaut 12, et la partie décimale est perdue avant la conversion en double ; m vaut 12,0 au lieu de 12,5. Cette erreur discrète, sans le moindre avertissement, se glisse facilement dans des calculs de moyenne, de taux ou de montant. En refusant de mélanger entiers et nombres à virgule sans conversion explicite, Rust, Go et Swift obligent le programmeur à dire ce qu’il veut, et la question ne peut plus passer inaperçue. Python et TypeScript évitent le problème autrement : leur opérateur / donne toujours un résultat à virgule.

5Les cinq grands

Cinq langages récents sont devenus des langages majeurs, chacun dans son domaine (figure 2). Ils ont chacun leur article.

À CHAQUE DOMAINE SES LANGAGES RÉCENTS (entre parenthèses : les langages établis) Programmation système, sûre et rapide Rust Zig Carbon (C, C++) Serveurs, cloud et Web Go TypeScript Elixir Gleam (Java, PHP) Applications mobiles Kotlin Swift Dart (Flutter) (Java, Objective-C) Calcul scientifique et IA Julia Mojo (Python, R, Fortran)
Figure 2. Les langages récents et les domaines où ils s’imposent.
  • Rust (Mozilla, 2015) : un langage système aussi rapide que le C et le C++, qui garantit la sûreté de la mémoire sans ramasse-miettes, grâce à ses règles de propriété et d’emprunt vérifiées à la compilation. Entré dans le noyau Linux, Android et Windows, il est le langage le plus apprécié des développeurs depuis 2016 (voir Rust).
  • Go (Google, 2009) : un langage volontairement simple, rapide à compiler, qui produit un seul fichier exécutable et rend facile la programmation concurrente. Docker, Kubernetes et la plupart des outils du cloud sont écrits en Go (voir Go).
  • TypeScript (Microsoft, 2012) : JavaScript augmenté de types vérifiés avant l’exécution. Devenu la norme des grandes applications Web, il est depuis 2025 le premier langage de GitHub en nombre de contributeurs (voir TypeScript).
  • Kotlin (JetBrains, 2016) : un langage concis, compatible avec Java, qui protège contre les valeurs nulles. Langage recommandé pour Android depuis 2019, il permet aussi de partager du code avec l’iPhone (voir Kotlin).
  • Swift (Apple, 2014) : le langage des appareils Apple, sûr et rapide, avec ses optionnels, son comptage automatique de références et, depuis 2024, la vérification des accès simultanés (voir Swift).