Clojure ist ein moderner Lisp-Dialekt, der auf der Java Virtual Machine läuft und funktionale Programmierung mit unveränderlichen Datenstrukturen in den Mittelpunkt stellt. Er eignet sich für Webanwendungen, Datenverarbeitung und nebenläufige Systeme.

Erste Schritte

Clojure-Code wird in Dateien mit der Endung .clj gespeichert. Die REPL (Read-Eval-Print-Loop) ist der zentrale Arbeitsplatz — Code wird sofort ausgewertet.

clojure                 # REPL starten
clojure -M hallo.clj    # Skript ausführen
lein repl               # REPL über Leiningen (Build-Tool)

Basissyntax

Alles in Clojure ist ein Ausdruck in Klammern: (Funktion Argumente ...). Es gibt keine Zuweisungen im klassischen Sinne, sondern Werte und Bindungen.

(println "Hallo Welt")        ; Ausgabe
(def name "Lübeck")            ; globale Bindung
(let [x 10 y 20] (+ x y))      ; lokale Bindungen -> 30
(+ 1 2 3)                      ; 6 (Präfixnotation)

Unveränderliche Datenstrukturen

(def v [1 2 3])                ; Vektor
(conj v 4)                     ; [1 2 3 4] (neuer Vektor)
(def m {:name "Devon" :ort "Lübeck"})
(:name m)                      ; Devon
(get m :ort)                   ; Lübeck

Funktionen

(defn verdoppeln [n] (* n 2))
(verdoppeln 21)                ; 42
(map inc [1 2 3])              ; (2 3 4)
(filter even? (range 10))      ; (0 2 4 6 8)

Nebenläufigkeit

Clojure bietet atom für geteilten, synchronisierten Zustand und future für parallele Berechnungen.

(def zaehler (atom 0))
(swap! zaehler inc)            ; atomar erhöhen
@zaehler                       ; 1 (dereferenzieren)
(future (Thread/sleep 100) 42) ; parallele Berechnung

Praxis-Tipps

• Präfixnotation und Klammern wirken ungewohnt — nach kurzer Eingewöhnung ist die Syntax extrem konsistent.
• Unveränderliche Datenstrukturen erleichtern nebenläufige Programme enorm.
• Für Web-Entwicklung sind Ring (HTTP) und Compojure beliebte Bibliotheken.

Verwandte Grundlagen: Haskell-Befehle und Scala-Befehle.

OCaml ist eine funktionale Programmiersprache mit starkem statischem Typsystem, die auch imperative und objektorientierte Elemente bietet. Sie wird für Compiler, statische Analysen und performante Systeme eingesetzt — der Rust-Konkurrent mit anderem Ansatz.

Erste Schritte

OCaml-Code wird in Dateien mit der Endung .ml gespeichert. Die REPL heißt ocaml, als Build-Tool etabliert ist dune mit dem Paketmanager opam.

ocaml                   # REPL starten
ocamlc hallo.ml         # Bytecode kompilieren
ocamlopt hallo.ml       # nativen Code kompilieren (schneller)
opam install dune       # Build-Tool installieren

Variablen und Typen

OCaml leitet Typen automatisch ab, prüft sie aber zur Compile-Zeit strikt. let bindet Namen an Werte, ;; schließt eine Top-Level-Eingabe in der REPL ab.

let name = "Welt";;
let x = 10;;
let add a b = a + b;;   (* Funktionsdefinition *)
add 3 4;;               (* 7 *)

Pattern Matching

Pattern Matching ersetzt in OCaml weite Teile von if/switch und ist eines der stärksten Sprachfeatures.

let beschreibe n = match n with
  | 0 -> "null"
  | 1 -> "eins"
  | _ -> "viel";;
beschreibe 5;;          (* "viel" *)

Listen und Optionen

let liste = [1; 2; 3];;
List.map (fun x -> x * 2) liste;;   (* [2; 4; 6] *)
let vielleicht = Some 42;;
match vielleicht with
  | Some w -> w
  | None -> 0;;                     (* 42 *)

Unveränderlichkeit

OCaml-Daten sind standardmäßig unveränderlich. Mit ref lassen sich veränderliche Zellen erzeugen, mit Array veränderliche Felder.

let zaehler = ref 0;;
incr zaehler;;          (* !zaehler ist jetzt 1 *)
let a = [|1; 2; 3|];;
a.(0) <- 99;;           (* Array ist veränderlich *)

Praxis-Tipps

• Der Typinferenz-Mechanismus fängt viele Fehler bereits beim Kompilieren.
• Dune + opam sind der Standard für neue Projekte.
• F# ist die .NET-Schwester von OCaml — Konzepte übertragen sich weitgehend.

Mehr funktionale Grundlagen: F#-Befehle und Haskell-Befehle.

VBA (Visual Basic for Applications) ist die Makrosprache der Microsoft-Office-Programme. Mit ihr automatisierst du Excel, Word und Access — von einfachen Zellberechnungen bis zu kompletten Berichts-Workflows.

Erste Schritte

VBA-Code wird im Visual Basic Editor (Alt+F11) geschrieben. Makros speicherst du in der Arbeitsmappe (als .xlsm-Datei) und startest sie über Alt+F8 oder ein Formular.

Sub HalloWelt()
    MsgBox "Hallo aus VBA"
End Sub

Variablen und Datentypen

Dim name As String
Dim zahl As Integer
Dim preis As Double
Dim ok As Boolean
name = "Lübeck"
zahl = 42

Zellen und Bereiche in Excel

Range("A1").Value = 100
Range("B1:B10").Value = "=ROW()*2"     ' Formel setzen
Cells(1, 3).Value = "C1"               ' Zeile 1, Spalte 3
Range("A1:D4").Interior.Color = RGB(200, 230, 255)
Worksheets("Daten").Activate

Kontrollstrukturen

If Range("A1").Value > 50 Then
    MsgBox "Groß"
Else
    MsgBox "Klein"
End If

For i = 1 To 10
    Cells(i, 1).Value = i
Next i

For Each zelle In Range("A1:A10")
    zelle.Font.Bold = True
Next zelle

Do While Range("A1").Value <> ""
    Range("A1").Offset(1, 0).Select
Loop

Schleifen über Tabellenblätter und Dateien

Dim ws As Worksheet
For Each ws In ThisWorkbook.Worksheets
    ws.Range("A1").Value = ws.Name
Next ws

Funktionen definieren

Function Flaeche(breite As Double, hoehe As Double) As Double
    Flaeche = breite * hoehe
End Function

' Aufruf: =Flaeche(5; 3) ergibt 15

Fehlerbehandlung

On Error Resume Next
Range("A1").Value = 1 / 0
If Err.Number <> 0 Then
    MsgBox "Fehler: " & Err.Description
    Err.Clear
End If

Praxis-Tipps

• Makros in Arbeitsmappen speichern: Datei → Speichern unter → Excel-Makro-fähige Arbeitsmappe (.xlsm).
• Mit Application.ScreenUpdating = False läuft VBA deutlich schneller.
• Office blockiert Makros aus dem Internet standardmäßig — vertrauenswürdige Dateien explizit freigeben.

Verwandte Grundlagen: PowerShell-Befehle und Batch/CMD-Befehle.

Objective-C ist die Erweiterung von C um objektorientierte Konzepte nach Smalltalk-Vorbild. Bis 2014 war sie die Hauptsprache für iOS- und macOS-Apps — heute lebt sie vor allem in Legacy-Codebasen und als Brücke zu C-Bibliotheken weiter.

Erste Schritte

Objective-C-Dateien heißen .h (Header) bzw. .m (Implementierung). Auf Apple-Systemen übersetzt der Clang-Compiler mit clang -fobjc-arc oder Xcode den Code.

clang -fobjc-arc -framework Foundation hallo.m -o hallo
./hallo

Klassen definieren

// Person.h
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property (nonatomic, strong) NSString *name;
- (void)gruss;
@end

// Person.m
#import "Person.h"
@implementation Person
- (void)gruss {
    NSLog(@"Hallo, %@", self.name);
}
@end

Objekte erzeugen und verwenden

Person *p = [[Person alloc] init];
p.name = @"Lübeck";
[p gruss];                 // Hallo, Lübeck

Methodenaufrufe mit eckigen Klammern

Kern der Smalltalk-Syntax: [Empfaenger Nachricht]. Argumente werden mit Doppelpunkt getrennt.

NSString *s = [NSString stringWithFormat:@"%d plus %d", 2, 3];
NSUInteger len = [s length];
NSLog(@"%lu Zeichen", (unsigned long)len);   // 5 Zeichen

Collections: NSArray, NSDictionary, NSSet

NSArray *zahlen = @[@1, @2, @3];
for (NSNumber *n in zahlen) {
    NSLog(@"%@", n);
}
NSDictionary *stadt = @{@"Name": @"Lübeck", @"PLZ": @"23552"};
NSLog(@"%@", stadt[@"Name"]);          // Lübeck

Blöcke (Closures)

void (^verdoppeln)(int) = ^(int n) {
    NSLog(@"%d", n * 2);
};
verdoppeln(21);                        // 42

ARC und Speicherverwaltung

Mit ARC (Automatic Reference Counting) übernimmt der Compiler das retain/release-Management. strong hält das Objekt, weak referenziert ohne Besitz (vermeidet Zyklen bei Delegates).

__weak Person *schwacheRef = p;   // kein Besitz

Praxis-Tipps

• Für neue Apple-Projekte ist Swift die empfohlene Sprache — Objective-C nur für Wartung und C-Interop.
• Header (.h) deklarieren, Implementierung (.m) definiert — das trennt API und Details.
• Methodennamen sind sprechend und selbstdokumentierend (stringWithFormat:, objectAtIndex:).

Verwandte Grundlagen: Swift-Befehle und C und C++.