HydraScript: Sprache mit statischer Typisierung und CGI für Docker

HydraScript: Vom Studentenprojekt zum statisch typisierten JSON-Parsing-CGI-Tool

Ein C#-Entwickler hat HydraScript erschaffen, eine Programmiersprache, die JavaScript-Syntax mit statischer Typisierung verbindet. Das Projekt entwickelte sich von einer Studienarbeit zu einem Open-Source-Tool, das CGI-Skripte für die Bereitstellung von Webdiensten in Docker unterstützt.

Vom Studentenprojekt zum Open-Source-Powerhouse

HydraScript entstand als Abschlussarbeit mit dem Titel „Erweiterte JavaScript-Untermenge“ am Fachbereich IU-9 der Bauman Moskauer Staatstechnischen Universität. Über vier Jahre hinweg in Teilzeit weiterentwickelt, wurde es zu einem vollwertigen Open-Source-Projekt mit GitHub Actions CI/CD, semantischer Versionierung und automatisierten Releases. Interpreter-Binaries werden für Windows (x64), macOS (arm64) und Linux (x64) mit Native AOT kompiliert – ohne Laufzeitabhängigkeiten.

Kernziele des Projekts:

• Teilweise JavaScript-Implementierung mit Objekten und struktureller statischer Typisierung – keine constructor-, class- oder interface-Keywords nötig.
• Öffentliche Reverse-Engineering moderner statischer Analysetechniken.
• Entmystifizierung von Compiler-Techniken durch Open-Source-Code.
• Sammlung klarer Implementierungen standardisierter Compiler-Herausforderungen.

Statische Analyse: Das Killer-Feature

Das Typsystem von HydraScript fängt Probleme zur Kompilierzeit auf, die andere Sprachen erst zur Laufzeit bemerken.

Erkennen von Zugriffen auf uninitialisierte Variablen

Der Interpreter verfolgt die Initialisierungsreihenfolge, um Laufzeitabstürze zu verhindern. Hier ein fehlerhaftes TypeScript/JavaScript-Beispiel:

let x = f()
function f() {
    console.log(x) // Fehler: x vor Zuweisung referenziert
    return 5
}

HydraScript markiert das bereits zur Kompilierzeit.

Intelligente Standardwerte

Im Gegensatz zu C#, wo uninitialisierte Lokale Kompilierfehler verursachen, weist HydraScript basierend auf abgeleiteten Typen automatisch Standardwerte zu:

let x: number
>>> x // 0

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

let s: string
>>> ~s // 0 (String-Länge)

Getrennte Namensräume für Symbole

Die Sprache verwendet drei Symboltypen: VariableSymbol, TypeSymbol und FunctionSymbol. Namen müssen nur innerhalb ihres Typs eindeutig sein, was flexible Wiederverwendung ermöglicht:

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

CGI-Unterstützung für Webentwicklung

Um HydraScript für Backend-Arbeit praktikabel zu machen, unterstützt es nun CGI-Skripte. Dafür waren nötig:

• String-Manipulations-API
• Stdout-Ausgabe
• Lesen von Umgebungsvariablen
• Shebang-Kommentar-Unterstützung

Docker-Bereitstellung einrichten

Docker-Image-Konfiguration basierend auf Apache httpd mit HydraScript-Interpreter:

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

Beispiel-CGI-Skript: Query-String zu JSON parsen

Dieses Skript wandelt URL-Parameter in strukturiertes JSON um und zeigt einen realen Anwendungsfall:

#!/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()

Für a=1&b=bla&c=false gibt es aus:

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

Wichtige Erkenntnisse

• HydraScript verbindet JavaScript-Syntax mit statischer Typisierung – ohne Klassen oder Konstruktoren.

• Die statische Analyse verhindert gängige Fehler wie Zugriffe auf uninitialisierte Variablen.

• CGI-Skripte ermöglichen Webentwicklung mit einfacher Docker-Bereitstellung.

• Vollständig Open Source mit CI/CD, semantischer Versionierung und plattformübergreifenden Builds.

— Editorial Team