Solidity ist die wichtigste Sprache für Smart Contracts auf der Ethereum-Blockchain. Sie ist objektorientiert, statisch typisiert und wird über den Compiler solc in Bytecode für die Ethereum Virtual Machine (EVM) übersetzt.

Kernbefehle und Struktur

• pragma solidity ^0.8.0; — legt die Compiler-Version fest.
• contract Token { ... } — definiert einen Smart Contract (ähnlich einer Klasse).
• constructor() { ... } — wird einmalig beim Deployment ausgeführt.
• function transfer(address to, uint amount) public { ... } — definiert eine Funktion mit Sichtbarkeit (public, private, internal, external).
• modifier onlyOwner() { ... } — kapselt Zugriffsprüfungen und wiederverwendbare Logik.
• require(bedingung, "Fehlermeldung"); — prüft Bedingungen und macht die Transaktion bei Fehlschlag rückgängig.
• revert("Grund"); — bricht die Ausführung bewusst ab.
• event Transfer(address indexed from, address indexed to, uint value); — deklariert ein Event für die Blockchain-Logausgabe.
• mapping(address => uint) public balances; — assoziatives Datenfeld auf der Blockchain.
• msg.sender, msg.value — globale Variablen für Absender und überwiesenen Wert.

Gas und Sicherheit

Jede Operation auf der EVM kostet Gas — Entwickler optimieren Contracts, um die Gebühren zu senken. Seit Solidity 0.8 schlagen arithmetische Über- und Unterläufe automatisch fehl (Revert), in unchecked { ... }-Blöcken kann man diese Prüfung bewusst deaktivieren.

Der Compiler solc wird meist über das Build-Tool forge (Foundry) oder truffle aufgerufen; solc --version zeigt die installierte Compiler-Version an. Smart Contracts laufen auf der Ethereum-Blockchain; die Transaktionskosten hängen direkt vom Gas-Verbrauch des Bytecodes ab.

Wie Zig vermeidet auch Solidity versteckte Kosten: Dort, wo Zig Speicher explizit verwaltet, macht Solidity jede Ressourcennutzung über Gas sichtbar und abrechenbar. Verwandte Grundlagen: Java-Befehle.

Zig ist eine Systemprogrammiersprache, die als moderne Alternative zu C entwickelt wurde. Ihr Compiler ist zugleich Build-Tool, Test-Runner und Paketmanager — die wichtigsten Befehle laufen daher alle über das zig-Kommando.

Kernbefehle

• zig version — zeigt die installierte Compiler-Version an.
• zig init — erzeugt ein neues Projekt mit build.zig und src/main.zig.
• zig build — führt den Standard-Build-Schritt aus (Kompilieren nach zig-out/bin/).
• zig build run — baut und startet das Programm direkt.
• zig build test — kompiliert und führt alle Tests aus.
• zig test src/main.zig — führt Tests einer einzelnen Datei aus.
• zig build-exe datei.zig — erzeugt direkt eine ausführbare Datei, ohne build.zig.
• zig run datei.zig — kompiliert und führt eine Datei in einem Schritt aus.
• zig fmt — formatiert Quellcode automatisch (kanonischer Stil).
• zig translate-c — übersetzt C-Header in Zig-Deklarationen für die Interop.

Besonderheiten

Zig verzichtet auf eine Garbage Collection und verwaltet Speicher explizit. comptime erlaubt Metaprogrammierung, bei der Code bereits zur Compile-Zeit ausgeführt wird — so bleiben typsichere Optimierungen möglich. Fehler werden über Error Unions behandelt, defer sorgt für Aufräumarbeiten am Ende eines Blocks.

Das Build-System ersetzt Makefiles und CMake durch eine in Zig geschriebene build.zig-Datei, mit der sich Abhängigkeiten und Cross-Kompilierung verwalten lassen.

In seiner Design-Philosophie ähnelt Zig dem Scheme-Ansatz: Beide Sprachen setzen auf Klarheit und minimale Magie statt auf versteckte Abläufe — Zig verzichtet auf versteckte Speicherallokation, Scheme auf versteckte Kontrollfluss-Effekte.

Verwandte Grundlagen: C/C++-Befehle, Rust-Befehle, Go-Befehle, Assembly-Befehle.

Scheme ist ein minimalistischer Dialekt der Lisp-Familie und wurde in den 1970er-Jahren am MIT von Gerald Jay Sussman und Guy L. Steele entwickelt. Die Sprache besteht im Kern aus Klammerausdrücken, Funktionen und einer extrem klaren Semantik.

Grundbefehle

• (define x 42) — definiert eine Variable.
• (define (quadrat n) (* n n)) — definiert eine Funktion.
• (lambda (x) (+ x 1)) — erzeugt eine anonyme Funktion (Closure).
• (let ((a 1) (b 2)) (+ a b)) — bindet lokale Variablen.
• (if <bedingung> <dann> <sonst>) — bedingte Auswertung.
• (cond ((= x 0) 'null) (else 'sonst)) — mehrere Bedingungen.
• (car '(1 2 3)) und (cdr '(1 2 3)) — erstes Element bzw. Rest einer Liste.
• (cons 1 '(2 3)) — fügt ein Element vor eine Liste.
• (map (lambda (n) (* n 2)) '(1 2 3)) — wendet eine Funktion auf alle Elemente an.
• (apply + '(1 2 3)) — ruft eine Funktion mit einer Argumentliste auf.

Tail Recursion und Standards

Scheme garantiert proper tail recursion: Rekursion in Endposition verbraucht keinen zusätzlichen Stack, wodurch Schleifen idiomatisch als rekursive Funktionen geschrieben werden. Die Sprache ist statisch scoped und funktional geprägt, erlaubt aber auch imperative Stile.

Der aktuelle Standard ist R7RS (Revised7 Report, 2013), der das Kernsprach-Design von R5RS um Bibliotheken, Records und Exception-Handling ergänzt. Bekannte Implementierungen sind GNU Guile, CHICKEN, Chez Scheme, Gambit und Racket (mit Scheme-Wurzeln). Auch die funktionale Denkweise von Scheme lebt in modernen Sprachen weiter — etwa in den pure-Funktionen von Solidity, die keine Zustandsänderungen auslösen und dadurch deterministisch bleiben.

Verwandte Grundlagen: Clojure-Befehle, Haskell-Befehle, Elixir/Erlang-Befehle.

fdisk ist das klassische Werkzeug der Kommandozeile, um Partitionen auf Festplatten und SSDs anzulegen, zu löschen oder zu verändern. Es arbeitet direkt auf dem Datenträger – ohne grafische Oberfläche, dafür mit voller Kontrolle.

Partitionstabelle anzeigen

sudo fdisk -l /dev/sda

Listet alle erkannten Festplatten und ihre Partitionen auf. /dev/sda steht für die erste SATA-Festplatte, /dev/nvme0n1 für eine NVMe-SSD.

Interaktiv arbeiten

sudo fdisk /dev/sdb

Nach dem Start öffnet sich ein interaktiver Modus mit eigener Eingabeaufforderung. Die wichtigsten Befehle:

• p – Partitionstabelle anzeigen (print)
• n – neue Partition anlegen (new)
• d – Partition löschen (delete)
• t – Partitionstyp ändern
• w – Änderungen schreiben und beenden (write, Pflicht!)
• q – ohne Speichern beenden (quit)

Verwandte Befehle

Einen Überblick über die vorhandenen Partitionen liefert lsblk – mehr dazu im Artikel zu den ls-Befehlen. Nach dem Anlegen muss eine Partition formatiert und mit den mount-Befehlen eingebunden werden. Wie viel Platz noch frei ist, zeigen df und du.

Praxis-Tipps

• Vorsicht: w überschreibt die Partitionstabelle sofort – vorher Daten sichern.
• Für GPT-Festplatten gibt es moderne Alternativen wie parted und gdisk.
• fdisk läuft unter jedem Linux-System, auf SSDs ebenso wie auf klassischen Festplatten.
• Welche Dateisysteme auf einer Partition möglich sind, erklärt der Artikel Dateisysteme erklärt.