Die Vorfahren von JavaScript

JavaScript sieht aus wie C, verhält sich wie Scheme und wurde nach Java benannt – obwohl es mit Java nichts zu tun hat. Um diese Sprache zu verstehen, müssen wir zu ihren Urvätern zurückreisen.

ALGOL 58/60 - Die Syntax-DNA

ALGOL (ALGOrithmic Language) wurde 1958 von einem internationalen Komitee entwickelt. Die Sprache selbst setzte sich nie durch – aber ihre Syntax beeinflusste fast jede Sprache danach:

• Geschweifte Klammern { } für Blöcke
• Semikolons als Statement-Trenner
• Lexikalischer Scope und Rekursion
• if-else, for, while

LISP - Die funktionale DNA

Im selben Jahr entwickelte John McCarthy LISP. Von dort erbte JavaScript eines seiner mächtigsten Features: First-Class Functions – Funktionen als Werte, die übergeben und zurückgegeben werden können.

Fun Fact: ALGOL war so einflussreich, dass die Fachsprache den Begriff "ALGOL-like" für Sprachen mit geschweiften Klammern verwendet.

// ALGOL 60 - Die Syntax-Vorlage
begin
  integer i;
  for i := 1 step 1 until 10 do
    if i > 5 then
      print(i)
end

// Vergleich: JavaScript heute
for (let i = 1; i <= 10; i++) {
  if (i > 5) {
    console.log(i);
  }
}
// Die Ähnlichkeit ist kein Zufall!

Die geschweifte Klammer { } – das visuelle Markenzeichen von JavaScript – hat eine lange Reise hinter sich. Von ALGOL über BCPL und B bis zu C.

Der Stammbaum

• BCPL (1967) – Martin Richards, Cambridge
• B (1969) – Ken Thompson, Bell Labs
• C (1972) – Dennis Ritchie, Bell Labs

C wurde zur einflussreichsten Sprache des 20. Jahrhunderts. Ihre Syntax wurde zum Standard – nicht weil sie optimal war, sondern weil Unix und später Windows in C geschrieben wurden.

Warum JavaScript wie C aussieht

Als Brendan Eich 1995 JavaScript entwarf, gab es eine klare Vorgabe von Netscape: "Mach es so, dass es für C- und Java-Programmierer vertraut aussieht."

Das Ergebnis: JavaScript hat die Hülle von C, aber ein völlig anderes Innenleben. Die geschweiften Klammern sind Tarnung.

Fun Fact: Dennis Ritchie sagte einmal, C sei "a language that doesn't get in your way". JavaScript-Entwickler würden das anders sehen.

// C - Die Syntax-Vorlage für JavaScript
#include <stdio.h>

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    printf("5! = %d\n", factorial(5));
    return 0;
}

// JavaScript sieht fast identisch aus:
function factorial(n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}
console.log(`5! = ${factorial(5)}`);

Hier wird es interessant: Unter der C-artigen Oberfläche verbirgt sich eine funktionale Sprache. Douglas Crockford brachte es auf den Punkt:

"JavaScript ist Scheme im C-Gewand."

Scheme (1975) - Der heimliche Vater

Scheme, ein LISP-Dialekt von Guy Steele und Gerald Sussman, brachte ein revolutionäres Konzept: Closures – Funktionen, die sich ihre Umgebung "merken".

Brendan Eich war ein Scheme-Fan. Als er JavaScript entwarf, schmuggelte er Schemes mächtigste Features hinein:

• First-Class Functions – Funktionen als Werte
• Closures – Zugriff auf äußere Variablen
• Lexical Scope – Sichtbarkeit durch Position im Code

Self (1987) - Prototypen statt Klassen

Self von Sun Microsystems ging noch weiter: Keine Klassen, nur Prototypen. Objekte erben direkt von anderen Objekten. JavaScript übernahm dieses Konzept – sehr zum Leidwesen von Java-Entwicklern.

Fun Fact: JavaScript ist eine der wenigen Mainstream-Sprachen mit prototypischer Vererbung. Erst ES6 (2015) brachte die class-Syntax – die intern immer noch Prototypen verwendet!

// Closures - Von Scheme geerbt (1975)

// Eine Funktion, die eine Funktion zurückgibt
function createCounter() {
    let count = 0;  // Diese Variable "überlebt"

    return function() {
        count++;    // Closure: Zugriff auf äußere Variable
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

// Die Variable 'count' existiert nur in der Closure
// Von außen nicht zugänglich - Kapselung ohne Klassen!

// Das ist Scheme-Philosophie in JavaScript-Syntax.

Mai 1995. Netscape braucht dringend eine Skriptsprache für den Browser. Brendan Eich bekommt den Auftrag – und nur 10 Tage Zeit.

Die Vorgaben von Netscape

• "Mach es einfach – für Nicht-Programmierer"
• "Es muss wie Java aussehen" (Marketing-Deal mit Sun)
• "Es darf nicht Java sein" (Sun's Bedingung)

Eichs Entscheidungen

In diesen 10 Tagen traf Eich Entscheidungen, die das Web bis heute prägen:

• Syntax: Von Java/C (vertraut aussehen)
• Funktionen: Von Scheme (mächtig sein)
• Objekte: Von Self (flexibel sein)
• Typen: Dynamisch (schnell schreiben)

Der Name: Eine Marketing-Katastrophe

Die Sprache hieß erst Mocha, dann LiveScript. Der finale Name JavaScript war reines Marketing – um vom Java-Hype zu profitieren. Bis heute sorgt das für Verwirrung.

Fun Fact: Brendan Eich sagte später: "I did JavaScript in 10 days, and I've been making up for it ever since."

// JavaScript 1.0 (1995) - Netscape Navigator 2.0

// Dynamische Typen - schnell, aber gefährlich
var name = "JavaScript";
name = 42;        // Kein Fehler!
name = true;      // Auch nicht!

// Funktionen als Werte - von Scheme
var greet = function(name) {
    alert("Hello, " + name);
};

// Event-Handler - der ursprüngliche Zweck
document.forms[0].onsubmit = function() {
    if (document.forms[0].email.value === "") {
        alert("Bitte E-Mail eingeben!");
        return false;
    }
    return true;
};

// Das war's - Formularvalidierung im Browser.
// Niemand ahnte, was daraus werden würde.

Von der "Spielzeugsprache" zur dominierenden Programmiersprache der Welt – JavaScript hat eine bemerkenswerte Transformation durchgemacht.

Die Meilensteine

• 1997 – ECMAScript 1: Der Standard
• 2009 – Node.js: JavaScript erobert den Server
• 2012 – TypeScript: Microsoft fügt Typen hinzu
• 2015 – ES6: Die große Modernisierung
• 2020+ – Jährliche Updates, moderne Features

ES6 - Die Renaissance

ECMAScript 2015 (ES6) war ein Quantensprung: Arrow Functions, Klassen, Promises, Module, Destructuring. JavaScript wurde endlich erwachsen.

Das moderne Ökosystem

Heute ist JavaScript überall:

• Frontend: Vue.js, React, Angular
• Backend: Node.js, Deno, Bun
• Mobile: React Native, Ionic
• Desktop: Electron (VS Code, Slack, Discord)

Von ALGOL's geschweiften Klammern über Scheme's Closures zu Node.js – die DNA der Urväter lebt weiter. Brendan Eichs 10-Tage-Hack wurde zur Lingua Franca des Internets.

// Modernes JavaScript - Die Evolution komplett

// Arrow Functions (von Scheme inspiriert)
const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);

// Klassen (Syntactic Sugar für Prototypen)
class User {
    #password;  // Private Field (ES2022)

    constructor(name, email) {
        this.name = name;
        this.email = email;
    }

    async fetchData() {
        const response = await fetch(`/api/users/${this.name}`);
        return response.json();
    }
}

// Destructuring & Spread
const { name, email } = user;
const newUser = { ...user, role: 'admin' };

// Optional Chaining & Nullish Coalescing (ES2020)
const city = user?.address?.city ?? 'Unbekannt';

// 1958 → 2024: Von ALGOL zu Optional Chaining
// Die Reise geht weiter.