Von Assembler zu No-Code

Am Anfang gab es nur Nullen und Einsen. Keine Tastatur, keinen Bildschirm – nur Schalter, Kabel und blinkende Lichter. "Programmieren" bedeutete: Hardware manipulieren.

ENIAC (1945)

Der erste elektronische Computer füllte einen ganzen Raum: 30 Tonnen, 18.000 Röhren, 150 Kilowatt Stromverbrauch. Um ihn zu programmieren, mussten 6 Frauen – die ersten Programmiererinnen der Geschichte – tagelang Kabel umstecken.

• Jean Bartik, Betty Holberton und Kolleginnen
• Keine Dokumentation, keine Handbücher
• Trial and Error mit 18.000 Röhren

Der echte "Bug"

1947 fand Grace Hopper eine Motte im Harvard Mark II – sie klebte den Käfer ins Logbuch mit der Notiz "First actual case of bug being found." Der Begriff "Debugging" war geboren.

Bits und Bytes direkt

Programme waren Folgen von Nullen und Einsen:

10110000 01100001 = "Lade den Wert 97 in Register AL"

Fun Fact: Die ENIAC-Programmiererinnen wurden jahrzehntelang vergessen – erst in den 1980ern erkannte man ihre Pionierleistung.

; Maschinensprache - direkte CPU-Befehle

Binär:          Bedeutung:
10110000        MOV AL, ...  (Lade Wert in Register AL)
01100001        97           (ASCII für 'a')

10110011        MOV BL, ...  (Lade Wert in Register BL)
00000010        2            (Multiplikator)

11110110        MUL BL       (Multipliziere AL mit BL)
11100011

; Ergebnis: AL = 194

; Kein "Programm" im heutigen Sinne
; Nur rohe Anweisungen für den Prozessor
; Ein Tippfehler = Systemabsturz

1949 hatte jemand eine revolutionäre Idee: Statt Binärcode könnten Menschen Mnemonics schreiben – kurze, merkbare Abkürzungen. Ein Programm würde diese dann in Maschinencode übersetzen.

Die Geburt des Assemblers

Aus 10110000 01100001 wurde MOV AL, 61h – immer noch kryptisch, aber lesbar. Die wichtigsten Assembler-Dialekte:

• 6502 – Apple II, Commodore 64
• Z80 – ZX Spectrum, MSX
• x86 – IBM PC und Nachfolger

Die Demo-Szene

In den 80ern und 90ern trieben Hacker die Kunst des Assemblers auf die Spitze. 64 Kilobyte – mehr Speicher gab's nicht auf dem C64. Trotzdem entstanden audiovisuelle Kunstwerke, die heute noch beeindrucken.

Warum Assembler wichtig ist

Auch heute wird Assembler noch genutzt:

• Betriebssystem-Kernel – der erste Code beim Booten
• Treiber – direkte Hardware-Kommunikation
• Sicherheit – Reverse Engineering von Malware
• Performance – kritische Schleifen optimieren

Fun Fact: Die Demo "Second Reality" (1993) von Future Crew gilt als Meisterwerk – in reinem Assembler geschrieben.

; 6502 Assembler - "Hello World" auf dem C64
; Jeder Befehl = ein CPU-Zyklus

        .org $0801          ; Start im BASIC-Speicher

        ldx #$00            ; X-Register = 0 (Zähler)
loop:   lda message,x       ; Lade Zeichen aus Nachricht
        beq done            ; Wenn 0, dann fertig
        jsr $ffd2           ; KERNAL: Zeichen ausgeben
        inx                 ; X erhöhen
        jmp loop            ; Wiederholen

done:   rts                 ; Zurück zu BASIC

message:
        .byte "HELLO WORLD", 0

; Kompiliert: ~30 Bytes
; Direkter Hardware-Zugriff
; Volle Kontrolle, volle Verantwortung

1957 erschien FORTRAN (Formula Translation) – die erste weit verbreitete Hochsprache. Statt hunderte Assembler-Zeilen: eine mathematische Formel. Der Compiler übersetzte automatisch.

Der Durchbruch

FORTRAN bewies: Maschinen können für Menschen übersetzen. Die Produktivität explodierte:

• FORTRAN (1957) – Wissenschaft & Mathematik
• COBOL (1959) – Business & Verwaltung
• C (1972) – Systemprogrammierung
• Pascal (1970) – Lehre & strukturiertes Programmieren

Der Vergleich

Dieselbe Aufgabe – Zahlen von 1 bis 10 addieren:

• Assembler: ~20 Zeilen, CPU-spezifisch
• C: ~5 Zeilen, portabel
• Python: 1 Zeile: sum(range(1, 11))

Die Abstraktion wächst

Jede Generation abstrahiert mehr:

• Assembler abstrahiert Binärcode
• C abstrahiert Assembler
• Python abstrahiert Speicherverwaltung

Fun Fact: FORTRAN-Code aus den 1960ern läuft heute noch – in Klimamodellen, Kernphysik-Simulationen und bei der NASA.

// C - Die portable Hochsprache

// Dieselbe Logik wie Assembler, aber lesbar
#include <stdio.h>

int main() {
    int sum = 0;

    // Assembler: 20 Zeilen mit Registern
    // C: 3 Zeilen
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }

    printf("Summe: %d\n", sum);
    return 0;
}

// Der Compiler übersetzt nach Assembler
// Portabel: Derselbe Code auf x86, ARM, RISC-V
// "Write once, compile anywhere"

// 1957 FORTRAN: 10x produktiver als Assembler
// 1972 C: Der Standard für 50 Jahre

Die nächste Revolution kam mit Visual Basic (1991): Programme zusammenklicken statt tippen. Rapid Application Development (RAD) war geboren.

Die Idee

Warum Code schreiben, wenn man Buttons auf Formulare ziehen kann? Visual Basic führte die visuelle Entwicklung ein:

• Form Designer – UI per Drag & Drop
• Property Inspector – Eigenschaften klicken statt tippen
• Event Handler – Doppelklick → Code schreiben

Die RAD-Ära

• Visual Basic (1991) – der Pionier
• Delphi (1995) – VB mit Pascal-Power
• PowerBuilder (1991) – Enterprise-Fokus
• Access (1992) – Datenbanken für alle

Der Einfluss

Das RAD-Konzept lebt heute weiter:

• Webflow, Figma – Design ohne Code
• Scratch – Programmieren für Kinder
• Unreal Blueprints – Spielelogik visuell

Fun Fact: VB6-Anwendungen laufen heute noch in tausenden Unternehmen. Microsoft hat den Support 2008 eingestellt – die Apps laufen trotzdem weiter.

' Visual Basic 6 - RAD in Aktion
' Button auf Form gezogen → Doppelklick → Code

Private Sub cmdCalculate_Click()
    ' Keine Speicherverwaltung
    ' Keine Header-Dateien
    ' Keine Kompilierung nötig

    Dim price As Double
    Dim quantity As Integer

    price = Val(txtPrice.Text)
    quantity = Val(txtQuantity.Text)

    ' Direkte UI-Manipulation
    lblTotal.Caption = Format(price * quantity, "€#,##0.00")

    ' In C: 50+ Zeilen für dasselbe
    ' In VB: 10 Zeilen + visueller Designer
End Sub

' 1991: Revolution der Produktivität
' 2024: Das Konzept lebt in No-Code weiter

Die ultimative Abstraktion: Gar kein Code mehr. Was 1991 mit Visual Basic begann, erreicht heute seinen Höhepunkt.

Die No-Code Revolution

• Zapier (2011) – "Wenn X, dann Y" ohne Code
• Airtable (2012) – Excel trifft Datenbank
• Webflow (2013) – Websites ohne Code
• n8n (2019) – Open-Source Workflow-Automation
• Bubble (2012) – Komplette Web-Apps ohne Code

KI als Abstraktion

Seit 2022 gibt es eine neue Ebene: KI-Assistenten schreiben Code für uns.

• GitHub Copilot – Code-Completion auf Steroiden
• ChatGPT / Claude – "Schreib mir eine Funktion, die..."
• Cursor, Windsurf – KI-native IDEs

70 Jahre Abstraktion

Der Weg von MOV AX, BX zu "Automatisiere meine Rechnungen":

• 1945: Kabel stecken
• 1949: Assembler tippen
• 1957: Hochsprachen kompilieren
• 1991: UI zusammenklicken
• 2020: Workflows zeichnen
• 2024: Der KI erklären, was man will

Die beste Abstraktion ist die, bei der man nicht mehr merkt, dass man programmiert.

# n8n - Automatisierung ohne Code

name: "Neue Rechnung verarbeiten"

# Trigger: Neue E-Mail mit Anhang
trigger:
  type: email
  filter: "subject contains 'Rechnung'"

# Workflow: Visuell zusammengeklickt
nodes:
  - extract_pdf:
      type: pdf-parser
      input: email.attachment

  - analyze:
      type: openai
      prompt: "Extrahiere Rechnungsdaten als JSON"

  - save:
      type: google-sheets
      action: append_row
      data: "{{ analyze.output }}"

  - notify:
      type: slack
      message: "Neue Rechnung: {{ analyze.vendor }}"

# Von MOV AX, BX zu Drag & Drop
# 70 Jahre Abstraktion in Aktion