Programmiersprachen¶

Einleitung¶

“Ein guter Handwerker ist ein guter Handwerker, egal mit welchem Werkzeug er arbeitet.” - Unbekannt

Dieser Satz trifft auch auf uns Programmierer zu. Mit allen Werkzeugen, unseren Programmiersprachen, können wir gute Software entwickeln, genauso wie ein Handwerker mit verschiedenen Werkzeugen ein gutes Möbelstück bauen kann. Allerdings ist die Wahl der Programmiersprache für uns Programmierer oft entscheidender als die Werkzeugwahl eines Handwerkers. Denn es gibt Maschinen, die nur mit einer bestimmten Programmiersprache programmiert werden können, und die Wahl der Programmiersprache beeinflusst stark, wie produktiv und effizient wir arbeiten können.

Selbstverständlich lässt sich ein Betriebssystem in Assembler programmieren, aber um produktiv und effizient zu sein, empfiehlt es sich, eine höhere Programmiersprache zu verwenden.

In der heutigen Zeit gibt es eine Vielzahl von Programmiersprachen, die meisten davon haben ihre Daseinsberechtigung. Dennoch werden meistens die gleichen Sprachen verwendet. Ein wesentlicher Grund dafür ist, dass sich die meisten Unternehmen und Softwareentwickler auf die gleichen Sprachen spezialisiert haben und das Risiko scheuen, eine neue Sprache zu verwenden.

Deshalb möchten wir hier einige weniger gebräuchliche Programmiersprachen vorstellen. Unser Ziel ist es, die Entscheidung, eine neue Sprache zu verwenden, zu erleichtern und möglicherweise neue Perspektiven und Vorteile aufzuzeigen, die diese Sprachen bieten können.

Versuch¶

LISP¶

LISP, kurz für “LISt Processing”, ist eine Familie von Programmiersprachen, die für ihre Einfachheit, Ausdrucksstärke und einzigartigen Ansatz in der Programmierung bekannt ist. Entwickelt in den späten 1950er Jahren von John McCarthy, hat LISP unzählige andere Sprachen beeinflusst und ist auch heute noch in verschiedenen Bereichen wie künstliche Intelligenz, Sprachverarbeitung und symbolische Berechnung relevant.

Eine der charakteristischen Eigenschaften von LISP ist ihre interaktive Natur. LISP wird als REPL (Read-Eval-Print Loop)-Sprache bezeichnet, was bedeutet, dass Programmierer interaktiv Code schreiben, ihn auswerten und sofortiges Feedback erhalten können. Dieser interaktive Workflow fördert schnelles Prototyping, Experimentieren und Erforschen, was LISP zu einer ausgezeichneten Wahl für explorative Programmierung und schnelle Iterationen macht.

Syntax¶

Die Syntax von LISP dreht sich um symbolische Ausdrücke oder S-Expressions, die in Präfixnotation geschrieben werden. Dies bedeutet, dass Operatoren ihren Operanden vorausgehen, im Gegensatz zur Infixnotation in vielen anderen Programmiersprachen. Zum Beispiel wird die Addition in den meisten Sprachen als 1 + 2 geschrieben, in LISP jedoch als (+ 1 2).

Ein weiterer grundlegender Aspekt der LISP-Syntax ist der umfangreiche Einsatz von Klammern zur Kennzeichnung von verschachtelten Listen und Ausdrücken. Dies macht LISP äußerst lesbar ;) und eignet sich gut für Rekursion und symbolische Manipulation.

ToDo-Liste¶

Der bereitgestellte Code zeigt eine einfache ToDo-Liste, die in LISP implementiert ist. Er definiert Funktionen zum Hinzufügen von Aufgaben, Entfernen von Aufgaben, Ausgeben der ToDo-Liste und Verwalten der Liste durch eine Hauptschleife. Benutzer können mit dem Programm interagieren, indem sie Aktionen wie Hinzufügen von Aufgaben, Entfernen von Aufgaben nach Index, Drucken der aktuellen Liste von Aufgaben oder Beenden des Programms auswählen.

lisp-todo

Jede Funktion im Code erledigt eine spezifische Aufgabe im Zusammenhang mit der Verwaltung der ToDo-Liste. Zum Beispiel fügt add-task eine neue Aufgabe zur Liste hinzu, remove-task entfernt eine Aufgabe nach Index, und print-todo-list zeigt die aktuellen Aufgaben in der Liste an.

(defun add-task (task)
  "Add a task to the todo-list."
  (push task *todo-list*))

(defun remove-task (index)
  "Remove a task from the todo-list by index."
  (if (and (integerp index) (< index (length *todo-list*)))
      (setf *todo-list* (remove (nth index *todo-list*) *todo-list*))
      (format t "Invalid index. No task removed.~%")))

(defun print-todo-list ()
  "Print the current todo-list."
  (if *todo-list*
      (loop for task in *todo-list* do
            (format t "> ~a~%" task))
      (format t "No tasks in the todo-list.~%")))

Die Funktion todo-list dient als Haupteinstiegspunkt und präsentiert eine Menüliste mit Optionen, mit denen Benutzer mit der ToDo-Liste interagieren können. Sie verwendet eine Schleife, um den Benutzer wiederholt zur Eingabe aufzufordern und die entsprechende Aktion basierend auf ihrer Auswahl auszuführen.

(defun todo-list ()
  "Main loop for managing the todo-list."
  (loop
    (format t "~%Choose an action:~%")
    (format t "1. Add a task~%")
    (format t "2. Remove a task~%")
    (format t "3. Print todo-list~%")
    (format t "4. Quit~%")
    (let ((choice (read)))
      (case choice
        (1 (progn
             (format t "Enter task to add: ")
             (finish-output)
             (add-task (read-line))))
        (2 (progn
             (format t "Enter index of task to remove: ")
             (finish-output)
             (remove-task (read))))
        (3 (progn
             (format t "ToDo-List:~%")
             (finish-output)
             (print-todo-list)))
        (4 (return))
        (t (format t "Invalid choice. Please enter a number between 1 and 4.~%"))))))

Vor- und Nachteile¶

Die Einfachheit, leistungsstarken Funktionen, Flexibilität und die entwicklungsfreundliche REPL machen LISP bei Programmierern für bestimmte Aufgaben sehr beliebt. Die Homöikonizität von LISP, bei der Code und Daten die gleiche Syntax teilen, ermöglicht leistungsstarke Metaprogrammierfähigkeiten, wodurch LISP ideal für Aufgaben wie das Schreiben von domänenspezifischen Sprachen und das Implementieren komplexer Algorithmen ist.

Die umfangreiche Verwendung von Klammern und Präfixnotation in LISP kann jedoch für Neueinsteiger anfangs herausfordernd sein. Darüber hinaus können die Einfachheit und Flexibilität von LISP auch zu Codebasen führen, die schwer zu warten und zu verstehen sind, insbesondere wenn sie an Komplexität zunehmen.

Lua¶

Überblick¶

Lua ist eine leichtgewichtige, einbettbare und leistungsstarke Skriptsprache, die für die Einbettung in andere Anwendungen konzipiert wurde. Sie wurde 1993 von Roberto Ierusalimschy, Luiz Henrique de Figueiredo und Waldemar Celes an der Päpstlichen Katholischen Universität von Rio de Janeiro in Brasilien entwickelt. Lua wird in verschiedenen Bereichen wie Spieleentwicklung, eingebetteten Systemen und Skripterstellung für Anwendungen weit verbreitet eingesetzt.

Syntax¶

Die Syntax von Lua ist sehr kompakt und übersichtlich. Sie ähnelt am meisten der Syntax von Pascal.
Lua verwendet keine geschweiften Klammern { } zur Strukturierung von Code-Blöcken. Stattdessen werden Code-Blöcke durch Schlüsselwörter wie do, end, then etc. und Einrückungen strukturiert
Variablen müssen nicht deklariert werden und sind dynamisch typisiert. Der Typ einer Variablen ergibt sich aus dem zugewiesenen Wert
Lua verwendet = für Zuweisungen und == für Vergleiche
Kommentare beginnen mit – für einzeilige Kommentare oder –[[ für mehrzeilige Kommentare
Lua hat nur eine Datenstruktur: Tabellen. Diese flexiblen assoziative Arrays können Listen, Dictionaries, Objekte etc. repräsentieren
Funktionen sind “First Class Citizens” und können wie jeder andere Wert behandelt werden
Lua unterstützt prozedurale, funktionale und mit Metatables auch objektorientierte Programmierung
Die Syntax ist frei formatierbar mit Ausnahme von Zeilenumbrüchen vor öffnenden runden Klammern in Funktionsaufrufen

--[[
Mehr Code Beispiele können in 6_langs/lua gefunden werden.
]]
X = 10
if X > 0 then
    print("x ist positiv")
elseif X == 0 then
    print("x ist null")
else
    print("x ist negativ")
end

-- Array ähnliche tabelle
local t = { 10, 20, 30 }
print(t[2]) -- Ausgabe: 20

-- Wörterbuch-artige Tabelle
local person = { name = "John", alter = 30, angestellt = true }
print(person.name) -- Ausgabe: John

-- Tabellen können andere Tabellen enthalten
local matrix = { { 1, 2 }, { 3, 4 } }
print(matrix[2][1]) -- Ausgabe: 3

Beispiel Metatable¶

Vorteile von Lua:¶

Leichtgewichtig und portabel: Lua ist eine sehr kompakte und leichtgewichtige Skriptsprache, die sich leicht in andere Anwendungen einbetten lässt. Die Lua-Laufzeitumgebung ist nur wenige Kilobyte groß und plattformunabhängig
Einfache und übersichtliche Syntax: Lua hat eine saubere und minimalistische Syntax mit nur wenigen Schlüsselwörtern, was den Einstieg erleichtert
Schnelle Ausführung: Der Lua-Interpreter ist sehr effizient und die Ausführungsgeschwindigkeit von Lua-Code ist vergleichbar mit kompilierten Sprachen
Eingebettete Skriptfähigkeiten: Lua wurde speziell dafür entwickelt, in andere Anwendungen eingebettet zu werden und bietet eine gute C-Schnittstelle für die Integration
Flexibilität: Lua unterstützt verschiedene Programmierparadigmen wie imperativ, funktional und mit Metatables auch objektorientiert
Große Verbreitung in Spieleentwicklung: Lua ist sehr beliebt für das Scripting von Computerspielen und wird von vielen Game-Engines unterstützt

Nachteile von Lua:¶

Begrenzte Standardbibliothek: Im Vergleich zu Python hat Lua eine kleinere Standardbibliothek und weniger vorgefertigte Module
Kleinere Community und Dokumentation: Die Community von Lua ist etwas kleiner im Vergleich zu größeren Programmiersprachen und die Dokumentation ist dementsprechend nicht so genau.
Hauptsächlich für Einbettung konzipiert: Lua wurde primär für die Einbettung in andere Systeme entwickelt und ist weniger für eigenständige Anwendungen ausgelegt
Schwächere Objektorientierung: Objektorientierte Programmierung muss in Lua durch Metatables simuliert werden, da es kein natives Klassenkonzept gibt
Geringere Verbreitung außerhalb der Spieleentwicklung: Außerhalb der Spielebranche hat Lua eine geringere Verbreitung als andere Skriptsprachen

Zig¶

Im Jahr 2016 begann Andrew Kelley mit der Entwicklung von Zig, einer systemnahen, statisch typisierten, kompilierten Programmiersprache, die auf Sicherheit, Geschwindigkeit und Einfachheit ausgelegt ist.

Das Motto von Zig ist “C but with the problems fixed”.

Dabei wollte Kelley nicht den Weg von C++ (und Rust) gehen und so viele Features wie möglich hinzufügen, sondern stattdessen die guten Teile von C beibehalten und die schlechten Teile beheben.

Lösungen für Probleme in C¶

Macros

In C sind Makros eine häufige Quelle für Fehler und schwer zu debuggen. Zig ersetzt Makros durch comptime-Anweisungen, die zur Kompilierzeit ausgewertet werden.

Conditional compilation in Zig:

if (builtin.os == .windows){
 // do bad windows stuff
} else if (buitlin.os == .linux){
 // do good linux stuff
} else {
 // too bad not supported
 @compileError("unsupported OS");
}

DEFINE CONSTANTS

fn getBufferLen(): usize {
  return 666;
}
var buffer: [getBufferLen()]u8 = undefined;

Error handling

Mandatory but convenient error handling
Stack traces

pub fn main() !void {
  const fd = try os.openFile("foo.txt");
}

Cleanup

Mit dem defer-Statement kann man am Anfang eines Blocks schreiben was auf geräumt werden muss.
```
fn main() void {
  defer print("Goodbye, World!\n");
  print("Hello, World!\n");
}
```

Features¶

Generics

Durch compile-time values und da Typen auch Values in zig sind können Generics durch einfache Funktionen umgesetzt werden.

pub fn Queue(comptime Child: type) type {
    return struct {
        const This = @This();
        pub fn init(gpa: std.mem.Allocator) This {
            return This{
                .gpa = gpa,
                .start = null,
                .end = null,
            };
        }
        const Node = struct {
            data: Child,
            next: ?*Node,
        };
    };
}

C-Interop

Zen of zig¶

zig zen

 * Communicate intent precisely.
 * Edge cases matter.
 * Favor reading code over writing code.
 * Only one obvious way to do things.
 * Runtime crashes are better than bugs.
 * Compile errors are better than runtime crashes.
 * Incremental improvements.
 * Avoid local maximums.
 * Reduce the amount one must remember.
 * Focus on code rather than style.
 * Resource allocation may fail; resource deallocation must succeed.
 * Memory is a resource.
 * Together we serve the users.

Golang¶

Go wurde in 2012, von drei Google-mitarbeiter (darunter Ken Thompson) entwickelt, um Produktivität zu steigern, mit Fokus auf Parallelität und Netzwerkfunktionalität. Die Sprache ist kompiliert, open-source, hat eine Python-ähnliche Syntax und wurde für serverseitige Anwendungen entworfen. Go Programme haben geringe overhead und schnelle Laufzeiten.

Go hat ein eigenes Paketmanager und Ökosystem, verfügbar durch den CLI. Dort können auch Paketabhägigkeiten gesteuert werden.

Für den compiler wurde eine subset von Go Funktionalität in C implementiert. Mit diesem subset wurde dann der Go compiler geschrieben. Man könnte sagen, Golang wurde in Golang geschrieben.

Variablen sind statisch und stark typisiert. Datentypen können auch automatisch gefolgert werden. Die Sprache unterstützt Zeiger.

Vorgehen¶

Go runterladen und installieren

Go Erweiterung für Vs-code installieren (optional)

Go Code schreiben go_code

Mit go run main.go ausführen und go build main.go kompilieren

FastApi¶

In der Welt der Webentwicklung spielen APIs (Application Programming Interfaces) eine entscheidende Rolle, da sie die Kommunikation zwischen verschiedenen Systemen und Anwendungen ermöglichen. Eine der aufstrebenden Technologien, die die Art und Weise, wie Entwickler APIs erstellen und verwalten, neu definiert, ist FastAPI. In diesem Artikel werden wir untersuchen, was FastAPI ist, welche Hauptmerkmale es aufweist, welche Vorteile es bietet und wie es die Landschaft der Webentwicklung verändert.

FastAPI ist ein modernes und schnelles Web-Framework zur Erstellung von APIs mit Python 3.6+. Es wurde von Sebastián Ramírez entwickelt und zeichnet sich durch seine hohe Leistung, Benutzerfreundlichkeit und Robustheit aus. FastAPI verwendet Starlette für den Webteil und Pydantic für die Datenverwaltung, was eine leistungsstarke Kombination zur schnellen und effizienten Entwicklung von API-Anwendungen bietet.

Hauptmerkmale

Hervorragende Leistung: Ein herausragendes Merkmal von FastAPI ist seine Geschwindigkeit. Durch die Verwendung von ASGI (Asynchronous Server Gateway Interface) kann FastAPI eine große Anzahl gleichzeitiger Anfragen verarbeiten, was es zu einer ausgezeichneten Wahl für Hochleistungsanwendungen macht. Benchmark-Tests haben gezeigt, dass FastAPI in Bezug auf Geschwindigkeit mit Go und Node.js vergleichbar ist.

Type Hints und automatische Validierung: FastAPI nutzt die Type Hints von Python, um die Validierung und Serialisierung von Daten automatisch durchzuführen. Dies reduziert nicht nur die Menge an Boilerplate-Code, sondern verbessert auch die Sicherheit und Robustheit der Anwendungen.

Automatische Dokumentation: Einer der am meisten geschätzten Aspekte von FastAPI ist die automatische Erstellung interaktiver Dokumentationen für APIs. Durch die Nutzung von OpenAPI und Swagger generiert FastAPI automatisch eine über den Browser zugängliche Dokumentationsoberfläche, die Entwicklern ermöglicht, APIs intuitiv zu erkunden und zu testen.

Benutzerfreundlichkeit: Die Lernkurve von FastAPI ist relativ flach, besonders für Entwickler, die bereits mit Python vertraut sind. Die saubere und lesbare Syntax und der auf Type Hints basierende Ansatz machen das Framework auch für weniger erfahrene Entwickler zugänglich.

Unterstützung für WebSockets und GraphQL: Neben traditionellen REST-APIs unterstützt FastAPI auch WebSockets und GraphQL, wodurch Entwicklern mehr Möglichkeiten zur Erstellung moderner und interaktiver Anwendungen gegeben werden.

Vorteile von FastAPI

Schnelle Entwicklung: Die Kombination aus automatischer Validierung, automatisch generierter Dokumentation und intuitiver Syntax verkürzt die Zeit, die zur Entwicklung und Wartung von APIs benötigt wird, erheblich.

Skalierbarkeit: Dank der Unterstützung von ASGI und der asynchronen Architektur ist FastAPI hoch skalierbar und kann eine große Anzahl gleichzeitiger Verbindungen ohne Leistungseinbußen verarbeiten.

Bessere Wartbarkeit: Der Einsatz von Type Hints verbessert die Lesbarkeit des Codes und erleichtert die Wartung, wodurch Entwicklungsteams effizienter zusammenarbeiten und die Anzahl der Fehler reduzieren können.

Aktive und wachsende Community: FastAPI hat eine schnell wachsende Community, die Beiträge in Form von Paketen, Tutorials und Support leistet. Dieses blühende Ökosystem erleichtert es, Ressourcen und Unterstützung zu finden, wenn dies erforderlich ist.

Installation

Um FastAPI zu installieren und zu verwenden, müssen einige grundlegende Schritte befolgt werden. In diesem Leitfaden erfahren Sie, wie Sie FastAPI und seine Abhängigkeiten installieren und eine einfache Anwendung einrichten.

Voraussetzungen

Python 3.6 oder höher Ein Paketverwaltungstool wie pip

Schritt-für-Schritt-Anleitung

Python-Umgebung einrichten (optional) mit python -m venv myenv
Aktivieren Sie die virtuelle Umgebung:
- Auf Windows: myenv\Scripts\activate
- Auf macOS/Linux: source myenv/bin/activate
FastAPI und Uvicorn installieren with: pip install fastapi uvicorn
Erstellen Sie Ihre erste FastAPI-Anwendung:
Starten Sie die FastAPI-Anwendung as: uvicorn main:app –reload
Testen Sie Ihre API: Nachdem der Server gestartet ist, sollten Sie eine Ausgabe ähnlich der folgenden sehen: INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) Um die automatisch generierte Dokumentation zu sehen, gehen Sie zu http://127.0.0.1:8000/docs

Feature

FastAPI ist ein Framework, das zahlreiche Vorteile gegenüber anderen Tools zur Erstellung von APIs bietet. In diesem Abschnitt werden einige dieser Vorteile erläutert, wie die Verwendung von Dependency Injection zur Sicherung von Endpunkten und die Validierung von Daten mit Pydantic. Praktische Beispiele veranschaulichen diese Konzepte.

Dependency Injection

Dependency Injection (DI) ist ein Entwurfsmuster, das die Verwaltung von Abhängigkeiten auf deklarative und modulare Weise ermöglicht. In FastAPI ist DI einfach zu verwenden und bietet eine leistungsstarke Möglichkeit, Endpunkte zu schützen und sicherzustellen, dass kritische Operationen korrekt ausgeführt werden.

Beispiel: Schutz von Endpunkten mit Dependency Injection

Betrachten wir ein Beispiel, in dem wir einen Endpunkt mit einem Authentifizierungssystem schützen möchten. Wir erstellen eine Abhängigkeitsfunktion, die das Authentifizierungstoken überprüft:

from fastapi import Depends, FastAPI, HTTPException, status

app = FastAPI()

def verify_token(token: str):
    if token != "secret-token":
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid token",
        )
    return token

@app.get("/protected-route")
def protected_route(token: str = Depends(verify_token)):
    return {"message": "You have access to this protected route"}

In diesem Beispiel verwendet der Endpunkt /protected-route die Funktion verify_token als Abhängigkeit, um sicherzustellen, dass das Authentifizierungstoken gültig ist. Wenn das Token ungültig ist, wird eine HTTP 401 Ausnahme ausgelöst.

Verwendung von Pydantic

Pydantic ist eine Bibliothek zur Validierung und Serialisierung von Daten, die FastAPI zur effizienten und sicheren Verwaltung von Eingabe- und Ausgabedaten verwendet. Mit Pydantic können wir Datenmodelle einfach definieren und automatisch validieren lassen.

Beispiel: Definition und Validierung von Datenmodellen

Erstellen wir ein Datenmodell mit Pydantic und verwenden es zur Validierung der Eingabedaten eines Endpunkts:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.post("/items/")
def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

In diesem Beispiel definieren wir ein Item-Modell mit Pydantic. Wenn ein Client eine POST-Anfrage an /items/ mit JSON sendet, validiert FastAPI die Daten automatisch anhand des Item-Modells. Wenn die Daten ungültig sind, gibt FastAPI automatisch einen Fehler 422 zurück.

Beispiel: Automatische Serialisierung von Daten

Pydantic erleichtert auch die Serialisierung von Ausgabedaten. Wir können Pydantic-Modelle verwenden, um sicherzustellen, dass die Ausgabe eines Endpunkts dem definierten Modell entspricht:

class User(BaseModel):
    id: int
    name: str
    email: str

@app.get("/users/{user_id}", response_model=User)
def get_user(user_id: int):
    return User(id=user_id, name="John Doe", email="john.doe@example.com")

Bescrhreibung des Versuchs

In der datei 6_Langs/fastApiNew findet man eine RestApi, die mit FastApi erstellt wurde. Unter den Url http://127.0.0.1:8000/docs kann man eine Liste von Endpoint (Swagger) sehen Swagger.

Die RestApi biedet die folgenden Endpoints:

User-Authentifizierung kann: wenn der User authentifiziert ist, bekoomt eine JWT Tocken.
Außerdem gibt es eine Endpoint nur fur admin, der auf den User-Kont Zugriff hat.

Wie gesagt diese Api integriet shon Design Pattern wie Dependency Injection, der dem Entwickler hilft, um fast mit weniger Aufwand die Endpoints zu schutzen.

Vorteile

Die Framework ist sehr einfach und wegen der guten Leserbarkeit von Code ist sehr nutlich im Teamarbeit.

Fazit¶

Lisp¶

Ein Relikt aus vergangener Zeit, das immer noch eine treue Anhängerschaft hat. Lisp sollte man auf jeden Fall gehört haben, da es so viele Sprache beeinflusst hat.

Lua¶

Lua ist eine leichtgewichtige, einbettbare Skriptsprache mit einer klaren und kompakten Syntax. Ihre Stärke liegt in der Einbettung in andere Anwendungen, was sie besonders in der Spieleentwicklung und für eingebettete Systeme attraktiv macht

Man sollte Lua auf jeden Fall kennen, da es in vielen Anwendungen eingesetzt wird wie z.B. neovim und so ganz klar einen festen Platz in der Software Entwicklung besitzt, wenn es auch manche Schwächen besitzt.

Zig¶

Zig hat ganz klar viele Vorteile gegenüber C und C++. Es ist eine moderne Sprache mit guten Ideen, die durchaus sehr klug sind. Momentan ist Zig noch in der Entwicklung und es gibt noch einige Baustellen. Außerdem ist es noch ungeklärt, wer tatsächlich C ersetzen wird, Rust oder Zig, da sich die beiden Sprachen an die gleiche Zielgruppe wenden. Man sollte Zig auf jeden Fall im Auge behalten, da es durchaus Potential hat, z.B. in der Entwicklung von Embedded Systems, wo Rust viele Features nicht ausspielen kann.

alt text

Abschließend kann man sagen das es viele interessante Sprachen noch zu entdecken hat die meisten davon haben ihre Daseinsberechtigung und bringen einen klaren Mehrwert nicht nur für die Nutzer sondern auch für das Ökosystem der Software Entwicklung. Es lohnt sich also immer mal wieder über den Tellerrand zu schauen.

Quellen¶

https://lisp-lang.org/
https://www.youtube.com/watch?v=Gv2I7qTux7g (Zig-Road to 1.0)
zig.guide (Learn Zig Documentation)
ziglang.org (Zig Foundation Homepage)