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++.

YAML, TOML und JSON sind die drei wichtigsten textbasierten Datenformate der Softwarewelt. JSON dominiert den Datenaustausch zwischen Diensten, YAML die Konfiguration moderner Tools (Docker, Kubernetes, CI/CD), TOML ist die Wahl für schlanke, gut lesbare Konfigurationsdateien (z.B. Cargo.toml, pyproject.toml).

JSON: Datenaustausch überall

JSON (JavaScript Object Notation) ist ein Untermenge der JavaScript-Syntax: Objekte in geschweiften Klammern, Arrays in eckigen, Strings in doppelten Anführungszeichen.

{
  "name": "Lübeck",
  "plz": 23552,
  "tags": ["hanse", "wissen"],
  "aktiv": true
}

YAML: Lesbar und einrückungsbasiert

YAML (YAML Ain't Markup Language) verzichtet auf Klammern und nutzt Einrückung. Es ist das Standardformat für Docker-Compose, Kubernetes-Manifeste und GitHub-Actions-Workflows.

name: Lübeck
plz: 23552
tags:
  - hanse
  - wissen
aktiv: true
server:
  host: web1
  port: 443

TOML: Schlank und typisiert

TOML (Tom's Obvious Minimal Language) kombiniert Klammern für Tabellen mit einfachen key = value-Zeilen — ideal für Konfigurationen mit vielen Einzelwerten.

name = "Lübeck"
plz = 23552
aktiv = true

[server]
host = "web1"
port = 443

Konvertieren zwischen den Formaten

Mit Python, jq oder yq lassen sich die Formate leicht umwandeln:

# JSON → YAML (yq)
yq -P '.' data.json > data.yaml

# YAML → JSON (yq)
yq -o=json '.' data.yaml > data.json

# JSON hübsch formatieren (jq)
jq '.' data.json

In Python verarbeiten

import json, yaml, tomllib

data = json.load(open("data.json"))        # JSON lesen
cfg  = yaml.safe_load(open("config.yaml")) # YAML lesen
toml = tomllib.load(open("pyproject.toml", "rb"))  # TOML lesen

Wann welches Format?

• JSON: APIs, Webservices, Datenaustausch zwischen Programmen.
• YAML: komplexe Konfiguration mit Hierarchie und Kommentaren (Kubernetes, Docker Compose, CI/CD).
• TOML: einfache, flache Konfiguration mit klarer Typisierung (Rust Cargo, Python pyproject).
• Kommentare: JSON kann keine, YAML und TOML können #-Kommentare.

Praxis-Tipps

• YAML ist einbettungsempfindlich: Tabs sind verboten, konsistente Einrückung ist Pflicht.
• Für maschinellen Austausch JSON verwenden — es ist am striktesten und am schnellsten zu parsen.
• TOML ist die beste Wahl, wenn die Datei von Menschen gepflegt wird und flach bleibt.

Verwandte Grundlagen: Python-Befehle und Bash-Befehle.

Mit df (disk free) und du (disk usage) behalten Sie den Speicherplatz Ihres Linux-Systems im Blick: df zeigt die Auslastung ganzer Dateisysteme, du die Größe einzelner Verzeichnisse.

df: Dateisysteme anzeigen

df -h

Zeigt alle eingehängten Dateisysteme in menschenlesbarer Form (-h = human readable, z.B. 12G statt 12582912). Ohne Option werden Blöcke zu 1 KiB ausgegeben.

• df -h /home — nur das Dateisystem, das den Pfad enthält
• df -i — Inodes statt Blöcke (wichtig bei voller Inode-Tabelle: „No space left on device", obwohl Platz da ist)
• df -T — zeigt zusätzlich den Dateisystemtyp (ext4, xfs, tmpfs ...)

du: Verzeichnisgrößen ermitteln

du -sh /var/log

du -s fasst das Verzeichnis zusammen, -h liefert lesbare Größen. Ohne -s listet du jeden Unterordner einzeln auf.

• du -sh * — Größe aller Einträge im aktuellen Verzeichnis
• du -sh * | sort -h — aufsteigend sortierte Liste (größte Verzeichnisse unten)
• du --max-depth=1 -h /var — nur eine Ebene tief, praktisch für die Suche nach Speicherfressern
• du -sh ~/.cache — gezielt den Cache-Ordner prüfen, der oft unerwartet groß wird

Praxis-Tipp: df und du kombinieren

Wenn die Platte voll ist: zuerst df -h (welches Dateisystem?), dann du -sh /var/* 2>/dev/null | sort -h | tail -5, um den größten Verursacher zu finden. Mit du -x bleibt du innerhalb eines Dateisystems und zählt nicht doppelt eingehängte Pfade.

Verwandte Grundlagen: Dateisysteme erklärt und Prozesse mit ps, top und kill verwalten.

ssh (Secure Shell) öffnet eine verschlüsselte Konsole auf einem entfernten Rechner, scp kopiert einzelne Dateien dorthin und rsync synchronisiert ganze Verzeichnisbäume. Alle drei nutzen dasselbe SSH-Protokoll und dieselbe Authentifizierung.

ssh: Kommandozeile auf dem Remote-Server

ssh Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein.

• ssh -p 2222 benutzer@host — anderen Port verwenden (Standard: 22)
• ssh -i ~/.ssh/id_ed25519 benutzer@host — bestimmten Schlüssel nutzen
• ssh-copy-id benutzer@host — den eigenen öffentlichen Schlüssel auf dem Server hinterlegen, danach Login ohne Passwort
• ssh benutzer@host 'command' — Befehl direkt ausführen, ohne interaktive Shell

scp: Dateien kopieren

scp backup.tar.gz benutzer@host:/home/benutzer/

Kopiert die Datei auf den Server. In die andere Richtung: scp benutzer@host:/pfad/datei.txt .

• scp -r ordner benutzer@host:/ziel/ — rekursiv ganze Verzeichnisse kopieren
• scp -P 2222 datei benutzer@host:/ziel/ — großer Port-Buchstabe auf der Client-Seite (kleines -p wäre die Zeiterhaltung)

rsync: Synchronisieren mit Delta-Übertragung

rsync -avz /home/benutzer/www/ benutzer@host:/backup/www/

-a (archive) erhält Rechte, Zeiten und Links; -v ist ausführlich; -z komprimiert. rsync überträgt nur geänderte Teile — nach dem ersten Lauf ist eine Sicherung extrem schnell.

• rsync -avz --delete quelle/ ziel/ — löscht am Ziel, was an der Quelle fehlt (exakte Spiegelung — Vorsicht!)
• rsync -avzn quelle/ ziel/ — Trockenlauf (-n), zeigt ohne Änderung, was passieren würde
• rsync -avz --progress quelle/ ziel/ — Fortschrittsanzeige bei großen Kopien

Wichtig: Ein abschließender Schrägstrich bei quelle/ bedeutet „Inhalt des Ordners", ohne Schrägstrich wird der Ordner selbst ins Ziel gelegt. Das ist die häufigste rsync-Falle.

Verwandte Grundlagen: Rechte vergeben mit chmod und chown und Archive mit tar und gzip.