Zero : qu'est-ce que c'est ? Le langage de programmation pour agents IA

Un langage conçu autour de ses lecteurs

La plupart des langages de programmation ont été pensés pour les humains. Leurs grammaires optimisent ce qui compte pour les humains : syntaxe concise, idiomes expressifs, raccourcis « élégants ». Les compilateurs affichent leurs messages d'erreur en prose parce qu'un humain les lit. Les bibliothèques standard sont organisées selon ce que leurs auteurs ont trouvé mémorisable.

Zero part d'une autre prémisse. Ses lecteurs principaux sont les agents IA — des modèles de langage qui écrivent, déboguent et réparent du code pour le compte de quelqu'un. Les humains restent dans la boucle, mais le langage traite les agents comme des utilisateurs de premier ordre dès le premier jour. Ce simple basculement se répercute sur presque toutes les fonctionnalités visibles du langage.

Zero est développé par Vercel Labs, vit sur zerolang.ai et est open source à l'adresse github.com/vercel-labs/zero. Les fichiers source ont l'extension .0.

pub fun main(world: World) -> Void raises {
    check world.out.write("hello from zero\n")
}

Cinq éléments dans ce snippet — pub, World, raises, check, et l'explicite world.out.write — vous en disent déjà beaucoup sur la façon dont Zero pense. On va dérouler chacun d'eux ci-dessous.

« Tout est explicite »

Le slogan officieux de la documentation de Zero, c'est tout est explicite. Le langage évite délibérément ce genre de machinerie cachée qui rend les autres langages système confortables pour les humains, mais traîtres pour les générateurs de code :

• Pas de ramasse-miettes obligatoire.
• Pas d'allocateur caché.
• Pas de runtime asynchrone implicite.
• Pas de globales magiques — pas de stdout ambiant, pas de process.env, pas de système de fichiers implicite.

Tout ce qu'une fonction fait et qui touche au monde extérieur doit apparaître dans sa signature. Ça fait beaucoup à taper pour un humain ; pour un agent qui raisonne sur ce qu'une fonction fait vraiment, c'est un cadeau.

Des capacités, pas des globales

La façon dont Zero gère les E/S est l'illustration la plus claire de cette philosophie. Il n'y a pas de fonction print globale. La sortie passe par une valeur World que le runtime remet à main :

pub fun main(world: World) -> Void raises {
    check world.out.write("hello\n")
}

Si une fonction au fond de votre pile d'appels veut écrire une ligne de log, il faut lui passer un World (ou une capacité plus restreinte) explicitement. Vous pouvez lire la signature d'une fonction et savoir — sans lire son corps — si elle pourrait toucher au réseau, au système de fichiers ou à stdout. C'est le genre de propriété sur laquelle un analyseur statique (ou un agent qui fait une revue de code) peut s'appuyer.

La capacité World creuse cette idée plus loin.

Échec explicite avec raises et check

Les fonctions qui peuvent échouer le déclarent. Les appelants qui invoquent des fonctions faillibles le reconnaissent. Pas de lancer silencieux :

fun validate(ok: Bool) -> i32 raises { InvalidInput } {
    if ok == false {
        raise InvalidInput
    }
    return 42
}

pub fun main(world: World) -> Void raises {
    check validate(true)
    check world.out.write("ok\n")
}

raises { InvalidInput } sur validate signifie « cette fonction peut échouer avec InvalidInput ». check sur le site d'appel signifie « si ça échoue, propage l'erreur vers le haut ». Vous ne pouvez pas accidentellement laisser tomber une erreur — elle apparaît dans la signature de votre fonction, ou alors le compilateur vous arrête. Voir Raises et Check pour l'histoire complète.

Un compilateur qui parle aux agents

L'élément le plus distinctif de Zero n'est pas une fonctionnalité de syntaxe — c'est la sortie du compilateur. Lancez zero check --json sur un programme cassé et vous obtenez quelque chose comme ceci :

{
    "ok": false,
    "diagnostics": [
        {
            "code": "NAM003",
            "message": "unknown identifier",
            "line": 3,
            "repair": { "id": "declare-missing-symbol" }
        }
    ]
}

Trois choses rendent cette sortie différente d'une erreur de compilation classique :

1. Codes d'erreur stables. NAM003 signifie « identifiant inconnu » aujourd'hui, et signifiera exactement la même chose dans la prochaine version du compilateur. Les agents peuvent faire de la reconnaissance de motifs sur le code sans avoir à analyser de l'anglais.
2. Métadonnées de réparation structurées. Le champ repair désigne un type de correction que le compilateur estime susceptible de résoudre l'erreur. Un agent peut récupérer le plan avec zero fix --plan --json et l'appliquer.
3. Aucune analyse de prose requise. Tout l'intérêt, c'est qu'un agent n'ait pas à interpréter un message destiné aux humains pour décider de la suite.

Diagnostics JSON détaille le format en profondeur.

Une petite surface, intentionnellement

La grammaire de Zero est petite et régulière — plus proche dans l'esprit du C des débuts que d'un langage à tout faire comme Scala ou le C++ moderne. Le raisonnement est pragmatique : un agent doit pouvoir intérioriser tout le langage le temps d'une session sans rater les cas limites.

Concrètement, vous trouverez :

• Une seule façon de déclarer une fonction (fun ou pub fun).
• Une seule façon de lier une valeur locale (let).
• Une seule façon de modéliser les types produit (shape), une seule pour les types somme (choice), une seule pour les énumérations simples (enum).
• Une seule construction de filtrage par motifs (match).
• Une seule construction de boucle dans la version actuelle du langage (while).

Ce que vous ne trouverez pas — du moins à ce stade — c'est la surcharge d'opérateurs, les conversions implicites, les macros, les décorateurs, ou trois façons concurrentes d'exprimer la même idée. Ce n'est pas de l'ascétisme ; c'est un choix délibéré pour garder la surface assez petite pour qu'un agent choisisse rarement la mauvaise variante.

Ce que Zero n'est pas

Pour bien poser le décor :

• Pas un langage de script. Zero compile vers des binaires natifs. Les programmes sont petits (la doc évoque des exécutables de moins de 10 Ko) et n'embarquent pas de runtime.
• Ni Rust, ni Go, ni Zig. La syntaxe partage des ancêtres communs, mais les priorités sont différentes — Rust optimise la sûreté mémoire avec un système de types sophistiqué, Zero optimise la facilité d'apprentissage pour les agents avec un système de types délibérément minuscule.
• Pas stable. Zero est pré-1.0. L'équipe est claire sur le fait que des changements cassants atterriront s'ils servent les objectifs agent-first. Ne misez pas dessus pour quoi que ce soit de sérieux pour l'instant.
• Pas une fonctionnalité de la plateforme de déploiement Vercel. Même s'il vient de Vercel Labs, Zero n'est pas lié à Next.js ni à l'hébergement Vercel. C'est un langage système autonome.

Pourquoi essayer Zero aujourd'hui

Vous essaieriez Zero aujourd'hui si vous vous intéressez à :

• La façon dont un langage change quand ses contraintes de conception viennent des agents plutôt que des humains.
• Expérimenter des E/S à base de capacités sans adopter un langage de recherche.
• Voir à quoi ressemble une « sortie de compilateur structurée » en tant que fonctionnalité de premier ordre, plutôt qu'en surcouche.
• Donner du feedback à Vercel Labs sur un projet qui évolue activement.

Vous le mettriez de côté (pour l'instant) si vous avez besoin d'un langage stable pour du vrai travail, d'un écosystème de bibliothèques mature, ou d'un outillage multiplateforme au niveau de Rust ou Go.

La suite : installer Zero

Le prochain document détaille l'installation de la chaîne d'outils Zero et la compilation de votre premier programme. Comptez environ une minute en tout.