v3.0.1Enterprise Ready

Einführung in Velisch

Velisch ist eine moderne, statisch typisierte Programmiersprache für die KI-API-Entwicklung, die zu nativem Rust kompiliert wird.

Was ist Velisch?

Velisch 3.0.1 ist die nächste Generation einer Programmiersprache, die entwickelt wurde, um die Lücke zwischen High-Level-Skriptsprachen (wie Python oder TypeScript) und performanten Systemprogrammiersprachen (wie Rust) zu schließen. Sie kombiniert eine ausdrucksstarke Syntax mit strikter Typsicherheit, einer mächtigen Standardbibliothek und nativen KI/ML-Features.

Design-Prinzipien

Einfachheit

Klare, lesbare Syntax mit starker Typinferenz - schreibe weniger, erreiche mehr.

Rust-Performance

Kompiliert zu optimiertem Rust-Code für maximale Geschwindigkeit und Speichersicherheit.

Sicherheit Zuerst

Integrierte Security-Features wie Auth, Rate Limiting, Validierung und DSGVO-Compliance.

KI/ML Ready

Native Unterstützung für LLM-Integration, Embeddings, Agenten und ML-Workflows.

Typsystem

Velisch ist statisch typisiert, was bedeutet, dass Variablentypen zur Kompilierzeit bekannt sein müssen. Dies hilft, Fehler frühzeitig zu erkennen. Dennoch bietet die Sprache durch Typinferenz oft das Gefühl einer dynamischen Sprache.

Primitive Typen
  • string - UTF-8 Zeichenketten
  • number - 64-Bit Fließkommazahlen
  • boolean - Wahrheitswerte
  • void - Kein Rückgabewert
  • null - Explizit kein Wert
Collection Typen
  • List<T> - Dynamische Listen
  • Map<K, V> - Schlüssel-Wert-Paare
  • Optional<T> - Optionaler Wert
  • Result<T, E> - Fehlerbehandlung

Hello World API

@GET("/api/hello")
fn hello(): string {
    return "Hello, Velisch! 🚀";
}

@GET("/api/users/:id")
fn getUser(id: string): User {
    return db.find(User, id);
}

@Auth
@Role("admin")
@GET("/api/admin/users")
fn getAdminUsers(): List<User> {
    return db.findAll(User);
}

struct User {
    id: string,
    name: string,
    email: string,
}

Generics

Velisch unterstützt Generics, um wiederverwendbaren Code für verschiedene Typen zu schreiben:

// Eine generische Identitätsfunktion
fn identity<T>(value: T): T {
    return value;
}

let s = identity<string>("Test");
let n = identity<number>(123);

// Generics mit Constraints
fn serialize<T: Serialize>(item: T): string {
    return item.toJson();
}

DSGVO & Privacy

Native Unterstützung für Datenschutzanforderungen mit dem @Privacy Decorator:

struct User {
    id: string,
    name: string,
    @Privacy
    email: string,
    @Privacy
    phone: string,
    @Privacy
    ip_address: string,
}

@GET("/api/users/:id")
fn getUser(id: string): User {
    // Email, Phone, IP werden automatisch verschleiert
    return db.find(User, id);
}

@DELETE("/api/users/:id")
fn deleteUser(id: string): void {
    let user = db.find(User, id);
    secureDelete(user);
    db.delete(User, id);
}

Open Source & Gemeinschaft

Velisch 2.7 ist vollständig kostenlos und Open Source. Die Sprache darf von jedem genutzt, modifiziert und weiterentwickelt werden.

Lizenz: Velisch steht unter der MIT-Lizenz. Das bedeutet, du kannst es für private und kommerzielle Projekte nutzen, den Quellcode einsehen und deine eigenen Erweiterungen bauen.

Installation