HydraScript : langage avec typage statique et CGI pour Docker

HydraScript : d'un projet étudiant à un outil CGI de parsing JSON à typage statique

Un développeur C# a créé HydraScript, un langage de programmation mêlant la syntaxe JavaScript au typage statique. Le projet a évolué d'une thèse étudiante vers un outil open source supportant les scripts CGI pour déployer des services web dans Docker.

D'un projet étudiant à une référence open source

HydraScript est né d'une thèse intitulée « Sous-ensemble étendu de JavaScript » au département IU-9 de l'université technique d'État de Bauman à Moscou. Au fil de quatre ans de développement à temps partiel, il s'est transformé en un projet open source complet avec GitHub Actions CI/CD, versionnage sémantique et déploiements automatisés. Les binaires de l'interpréteur sont compilés pour Windows (x64), macOS (arm64) et Linux (x64) grâce à Native AOT, sans dépendances d'exécution.

Objectifs principaux du projet :

• Implémentation partielle de JavaScript avec objets et typage statique structurel — sans mots-clés constructor, class ou interface.
• Reverse-engineering public des techniques modernes d'analyse statique.
• Démystification des technologies de compilation via du code open source.
• Collecte d'implémentations claires des défis standards des compilateurs.

Analyse statique : la fonctionnalité phare

Le système de types d'HydraScript détecte les erreurs à la compilation là où d'autres langages ne les repèrent qu'à l'exécution.

Détection des accès à des variables non initialisées

L'interpréteur suit l'ordre d'initialisation pour éviter les plantages à l'exécution. Voici un code TypeScript/JavaScript problématique :

let x = f()
function f() {
    console.log(x) // Erreur : x référencé avant assignation
    return 5
}

HydraScript le signale à la compilation.

Valeurs par défaut intelligentes

Contrairement à C#, où les locales non initialisées provoquent des erreurs de compilation, HydraScript assigne automatiquement des valeurs par défaut selon les types inférés :

let x: number
>>> x // 0

let xArr: number[]
>>> xArr // []

let s: string
>>> ~s // 0 (longueur de chaîne)

Espaces de noms séparés pour les symboles

Le langage utilise trois types de symboles : VariableSymbol, TypeSymbol et FunctionSymbol. Les noms n'ont besoin d'être uniques que dans leur type, permettant un réemploi flexible :

type x = number
let x:x
function x(x:x) {
    >>>x
    x = x + 1
}
x(x)

Support CGI pour le développement web

Pour rendre HydraScript pratique en backend, il supporte désormais les scripts CGI. Cela a nécessité :

• API de manipulation de chaînes
• Sortie stdout
• Lecture des variables d'environnement
• Support des shebangs

Configuration de déploiement Docker

Configuration d'image Docker basée sur Apache httpd avec l'interpréteur HydraScript :

FROM mcr.microsoft.com/dotnet/sdk:10.0-alpine as sdk-build
RUN dotnet tool update -g hydrascript
ENV PATH="/root/.dotnet/tools:${PATH}"

FROM httpd:2.4-alpine
COPY --from=sdk-build /root/.dotnet/tools/ /usr/bin
RUN apk add dotnet10-runtime

Exemple de script CGI : parsing de chaînes de requête en JSON

Ce script convertit les paramètres d'URL en JSON structuré, illustrant un usage concret :

#!/usr/bin/hydrascript

type QueryStringParseResultItem = {
    name: string;
    value: string;
}

type QueryStringParseResult = {
    result: QueryStringParseResultItem[];
}

type QueryStringParser = {
    input: string;
}

function parse(parser: QueryStringParser): QueryStringParseResult {
    const qsLen = ~parser.input
    let i = 0
    let items: QueryStringParseResultItem[]

    let currentName: string, currentValue: string
    let isName = true
    while (i < qsLen) {
        const currentChar = parser.input[i]
        if (currentChar == "&" || i == qsLen - 1) {
            let addittion = i == qsLen - 1 && currentChar != "&" ? currentChar : ""
            items = items ++ [{name: currentName; value: currentValue + addittion;}] 
            currentName = ""
            currentValue = ""
            isName = true
        } else if (currentChar == "=") {
            isName = false
        } else {
            if (isName) {
                currentName = currentName + currentChar
            } else {
                currentValue = currentValue + currentChar
            }
        }
        i = i + 1
    }

    return {
        result: items;
    }
}

let parser: QueryStringParser = {
    input: $QUERY_STRING;
}

>>> "Content-Type: application/json\n\n"
>>>  parser.parse()

Pour a=1&b=bla&c=false, il produit :

{
  "result": [
    {"name": "a", "value": "1"},
    {"name": "b", "value": "bla"},
    {"name": "c", "value": "false"}
  ]
}

Points clés

• HydraScript combine la syntaxe JavaScript avec un typage statique — sans classes ni constructeurs.

• Son analyse statique prévient les bugs courants comme les accès à des variables non initialisées.

• Le support CGI permet le développement web avec un déploiement Docker simplifié.

• Entièrement open source avec CI/CD, versionnage sémantique et builds multiplateformes.

— Editorial Team