Programmiersprachen

Details: Zuletzt aktualisiert: 25. August 2026

programmiersprachen

Go: Konzepte für nebenläufige Systeme

Go (Golang) wurde bei Google entwickelt und ist für Server, CLI-Tools und Cloud-native Dienste beliebt. Sein Markenzeichen ist einfache Nebenläufigkeit.

Goroutines

Eine Goroutine ist ein leichtgewichtiger Thread: go funktion() startet sie. Tausende Goroutines sind normal – der Scheduler verteilt sie auf wenige OS-Threads.

Channels

Channels sind typisierte Kommunikationsröhren zwischen Goroutines:

ch := make(chan int)
go func() { ch <- 42 }()
wert := <-ch

Slices und Maps

slice := []int{1,2,3}, m := map[string]int{}. Slices wachsen dynamisch, Maps liefern value, ok := m[key].

Interfaces

Interfaces werden implizit erfüllt: Ein Typ genügt einem Interface, wenn er die Methoden hat. Das ermöglicht elegante Abstraktionen ohne Vererbung.

Typische Einsatzgebiete

Web-APIs (net/http, Gin, Echo).
CLI-Tools (Docker, kubectl, Hugo sind in Go geschrieben).
Netzwerkdienste und Proxys.

Weiterführend: Programmiersprachen.

Details: Zuletzt aktualisiert: 25. August 2026

programmiersprachen

Rust: Sicherheit durch Ownership

Rust verbindet die Performance von C/C++ mit Speichersicherheit – ohne Garbage Collector. Das Herzstück ist das Ownership-Modell.

Ownership-Regeln

Jeder Wert hat genau einen Besitzer.
Wird der Besitzer verlassen, wird der Wert freigegeben.
Ausleihen (Borrowing) ist möglich, aber nur einer darf schreiben oder viele dürfen lesen.

Beispiel

fn main() {
    let s = String::from("Hallo");
    let laenge = berechne(&s);  // borrow
    println!("{}: {}", s, laenge);
}

fn berechne(s: &String) -> usize { s.len() }

Warum wichtig

Viele Sicherheitslücken (Buffer Overflows, Use-after-free) sind in C/C++ möglich, weil Speicher manuell verwaltet wird. Rust fängt diese Fehler zur Compile-Zeit ab.

Einsatzgebiete

Systemprogrammierung (Kernel-Module, Treiber).
WebAssembly.
Hochperformante Web-Services (Axum, Actix).

Weiterführend: Programmiersprachen.

Details: Zuletzt aktualisiert: 25. August 2026

Python für Einsteiger: Der pragmatische Einstieg in die Programmierung

Python ist seit Jahren eine der meistgenutzten Programmiersprachen der Welt – und das aus gutem Grund. Die Syntax ist lesbar, die Einstiegshürde niedrig, und trotzdem reicht das Ökosystem von kleinen Skripten bis zu großen KI- und Webanwendungen. Dieser Artikel zeigt den pragmatischen Einstieg: Was Python ausmacht, wie man es installiert und die ersten sinnvollen Programme schreibt.

Warum Python?

Python wurde 1991 von Guido van Rossum veröffentlicht und setzt von Anfang an auf Lesbarkeit. Einrückungen strukturieren den Code statt geschweifter Klammern – das erzwingt sauberen Stil. Drei Eigenschaften machen Python besonders attraktiv:

Große Standardbibliothek: Dateien, Netzwerk, JSON, Datenbanken – vieles ist ohne Zusatzpakete nutzbar.
Riesiges Ökosystem: Mit pip installiert man über 500.000 Pakete, von Web-Frameworks (Django, FastAPI) bis zu Datenanalyse (pandas) und KI (PyTorch, Transformers).
Breite Einsatzgebiete: Automatisierung, Web-APIs, Datenauswertung, Machine Learning und DevOps-Skripte.

Installation und erste Schritte

Unter Linux ist Python 3 meist vorinstalliert – prüfen mit:

python3 --version

Fehlt es, installiert man es über den Paketmanager (Debian/Ubuntu: sudo apt install python3 python3-pip, Arch: sudo pacman -S python python-pip). Unter Windows lädt man den Installer von python.org und aktiviert beim Installieren die Option „Add Python to PATH".

Das erste Programm als Datei hallo.py:

#!/usr/bin/env python3
name = input("Wie heißt du? ")
print(f"Hallo {name}, willkommen bei Python!")

Ausführen mit python3 hallo.py. Die f-Zeichenkette setzt Variablen direkt in den Text – eine der elegantesten Python-Eigenschaften.

Variablen, Datentypen und Kontrollfluss

Python ist dynamisch typisiert: Variablen brauchen keine Typdeklaration.

alter = 30              # int
name = "Michael"        # str
groesse = 1.82          # float
ist_admin = True        # bool
hobbys = ["Linux", "KI"]  # Liste

if alter >= 18 and ist_admin:
    print("Zugriff erlaubt")
for hobby in hobbys:
    print(f"- {hobby}")

Listen, Tupel, Dictionaries und Mengen decken die meisten Datenstrukturen ab. Ein Dictionary (ähnlich einer JSON-Struktur):

server = {"name": "web01", "cpu": 4, "ram_gb": 16}
print(server["name"])
server["ram_gb"] = 32

Funktionen und Module

Funktionen kapseln Logik und machen Code wiederverwendbar:

def quadrat(x):
    """Berechnet das Quadrat einer Zahl."""
    return x * x

print(quadrat(7))  # 49

Eigene Module sind einfach Python-Dateien. Der Import funktioniert über den Dateinamen ohne Endung:

import quadratmodul   # lädt quadratmodul.py
from quadratmodul import quadrat

Virtuelle Umgebungen – der wichtigste Reflex

Pro Projekt eine eigene Umgebung: So kollidieren Paketversionen nicht. Ab Python 3.3 ist venv an Bord:

python3 -m venv .venv
source .venv/bin/activate   # Linux/macOS
# Windows: .venv\Scripts\activate
pip install requests

Die aktivierte Umgebung erkennt man am Präfix (.venv) in der Shell. Verlassen mit deactivate. In Produktion und CI/CD sind virtuelle Umgebungen oder Container (Docker) Pflicht, damit Builds reproduzierbar bleiben.

Praxisbeispiel: Web-Request mit requests

import requests

antwort = requests.get("https://api.github.com", timeout=10)
if antwort.status_code == 200:
    daten = antwort.json()
    print(f"API läuft: {daten.get('current_user_url')}")
else:
    print(f"Fehler: {antwort.status_code}")

Das Muster – Request, Status prüfen, JSON parsen – wiederholt sich in unzähligen Automatisierungen. Zusammen mit schedule oder Cron lassen sich daraus vollständige Monitoring- und Reporting-Skripte bauen (siehe auch Systemadministration).

Typische Anfängerfehler und wie man sie vermeidet

Einrückung mischen: Nie Tabs und Leerzeichen kombinieren; der Editor sollte Tabs in Leerzeichen umwandeln.
Pakete global installieren: Immer venv verwenden – sonst „funktioniert es auf meinem Rechner, aber nicht auf dem Server".
Ausnahmen verschlucken: Ein nacktes except: versteckt Fehler. Besser: except requests.RequestException as e: und den Fehler loggen.
Python 2 denken: print ist eine Funktion, Division / liefert Float. Moderner Code zielt auf Python 3.10+.

Dateien lesen und schreiben – die Basis jeder Automatisierung

Kaum ein Skript kommt ohne Dateizugriff aus. Python macht das angenehm kurz:

# Datei zeilenweise lesen
with open("server.log", encoding="utf-8") as f:
    for zeile in f:
        if "ERROR" in zeile:
            print(zeile.strip())

# Datei schreiben
with open("bericht.txt", "w", encoding="utf-8") as f:
    f.write("Ergebnis: OK\n")

Das with-Konstrukt schließt die Datei automatisch – auch bei Fehlern. Für strukturierte Daten ist JSON der Standard:

import json
daten = {"server": "web01", "status": "online"}
with open("status.json", "w", encoding="utf-8") as f:
    json.dump(daten, f, indent=2)

with open("status.json", encoding="utf-8") as f:
    geladen = json.load(f)
print(geladen["status"])

Dieses Muster – Logs durchsuchen, Ergebnisse als JSON ablegen – deckt einen großen Teil der täglichen Server-Automatisierung ab. Kombiniert mit schedule oder Cron entstehen daraus vollwertige Report- und Monitoring-Skripte.

Fehler behandeln statt abstürzen

Produktiver Code fängt Fehler gezielt ab:

try:
    antwort = requests.get(url, timeout=10)
    antwort.raise_for_status()
except requests.Timeout:
    print("Zeitüberschreitung – Server antwortet nicht")
except requests.HTTPError as e:
    print(f"HTTP-Fehler: {e.response.status_code}")
else:
    print("Erfolgreich geladen")

Die Regel: So spezifisch wie möglich fangen, den Fehler loggen, und dem Nutzer eine verständliche Meldung geben. Ein pauschales except Exception am Ende eines Skripts ist nur als letztes Auffangnetz akzeptabel.

Weiterführende Schritte

Wer Python ernsthaft einsetzen will, sollte als Nächstes Web-APIs mit FastAPI oder Flask bauen, Daten mit pandas auswerten oder sich der Automatisierung von Serveraufgaben widmen. Für die Arbeit mit Sprachmodellen und KI-Agenten ist Python ohnehin die dominierende Sprache – dazu mehr unter KI & Automatisierung.

Details: Zuletzt aktualisiert: 25. August 2026

PHP für Webentwicklung: Moderne Praxis statt Legacy-Code

PHP treibt noch immer rund drei Viertel aller Websites an – von kleinen Blogs bis zu großen Systemen wie WordPress, Joomla oder Laravel-Anwendungen. Der schlechte Ruf aus den 2000er-Jahren ist längst überholt: Modernes PHP (ab Version 8) ist typsicher, schnell und gut testbar. Dieser Artikel zeigt, wie zeitgemäße PHP-Entwicklung aussieht und worauf es in der Praxis ankommt.

Warum PHP 2026 immer noch relevant ist

Verbreitung: Kaum ein Shared-Hosting-Anbieter ohne PHP-Unterstützung – günstig und überall verfügbar.
Reife Ökosysteme: Composer als Paketmanager, Frameworks wie Laravel und Symfony, CMS wie Joomla und WordPress.
Performance: Mit PHP 8.x und OpCache ist PHP für die meisten Web-Anwendungen schnell genug – und mit FrankenPHP (Go-basierter App-Server) sogar für anspruchsvollere Last.
Einfacher Einstieg: Eine Datei, ein Webserver, fertig. Ideal für Prototypen und kleinere Dienste.

Grundlagen: Variablen, Arrays, Funktionen

<?php
$name = "Michael";
$alter = 42;
$preise = [12.99, 8.50, 3.20];        // Array
$nutzer = ["id" => 1, "name" => "ki"]; // Assoziatives Array

function brutto(float $netto, float $satz = 0.19): float {
    return $netto * (1 + $satz);
}
echo brutto(100.0); // 119.0
?>

Wichtig: PHP-Dateien, die nur Logik enthalten, schließen ohne ?> – das verhindert versehentlich ausgegebenen Whitespace, der Header-Probleme verursacht.

Moderne Sprachelemente (PHP 8+)

Seit PHP 8.0 (November 2020) hat sich die Sprache fundamental verbessert:

Named Arguments: function erstelle_user(name: "ki", admin: true) – Argumente beim Namen nennen.
Union Types: function finde(int|string $id): ?User – präzise Typen statt Docblocks.
Match-Ausdruck: Ersetzt lange switch-Ketten: $status = match($code) { 200 => 'ok', 404 => 'missing', default => 'unknown' };
Nullsafe-Operator: $user?->profil?->email – bricht sauber bei null ab.
Readonly-Klassen und Enums: Seit 8.1/8.2 für klare Domänenmodelle.

Projektstruktur und Composer

Composer ist der Paketmanager – so wie pip für Python oder npm für JavaScript:

composer require guzzlehttp/guzzle   # HTTP-Client
composer require vlucas/phpdotenv    # .env-Konfiguration

Eine saubere, kleine Struktur für ein Web-Projekt:

projekt/
  public/          # DocumentRoot – nur hier liegt Erreichbares
    index.php      # Front-Controller (Router)
  src/             # Anwendungscode
  config/          # Konfiguration
  vendor/          # Composer-Abhängigkeiten (nie ins Git!)

Der Front-Controller leitet alle Requests an index.php weiter. Dazu eine .htaccess (Apache) oder eine nginx-Konfiguration mit try_files $uri $uri/ /index.php?$query_string;.

Sicherheit: Die vier häufigsten Fallen

SQL-Injection: Nie Werte direkt in Queries concatenaten. Immer Prepared Statements (PDO):

$stmt = $pdo->prepare("SELECT * FROM user WHERE email = ?");
$stmt->execute([$email]);

XSS (Cross-Site Scripting): Jede Ausgabe escapen: <?= htmlspecialchars($wert, ENT_QUOTES, 'UTF-8') ?>
CSRF: Bei Formularen ein Token mitsenden und prüfen (z.B. $_SESSION['csrf']).
Datei-Uploads: Erlaubte MIME-Typen whitelisten, Dateien außerhalb des Webroots speichern und per Hash umbenennen.

Wer diese vier Regeln befolgt, ist bereits sicherer als die Mehrheit der PHP-Anwendungen im Internet.

Praxis: Kleine REST-API mit PDO

<?php
declare(strict_types=1);
require 'vendor/autoload.php';

$pdo = new PDO(
    'mysql:host=localhost;dbname=app;charset=utf8mb4',
    getenv('DB_USER'), getenv('DB_PASS'),
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);

header('Content-Type: application/json');
$stmt = $pdo->query("SELECT id, titel FROM artikel ORDER BY id DESC LIMIT 10");
echo json_encode($stmt->fetchAll(PDO::FETCH_ASSOC));

So entstehen in wenigen Minuten funktionierende JSON-Endpunkte – das Grundmuster hinter vielen Web-APIs, auch im Hanse-Computing-Umfeld (z.B. Webradio-API, siehe HTTP/HTTPS-Grundlagen).

Deployment in der Praxis

OpCache aktivieren (opcache.enable=1, opcache.validate_timestamps=0 in Produktion).
Fehleranzeige aus: display_errors=0, stattdessen Logs (error_log).
Composer mit composer install --no-dev --optimize-autoloader.
Dateirechte: Webserver darf nur lesen, Schreibzugriff nur wo nötig (Uploads, Cache).
Backups und Deploy-Strategie: Siehe Systemadministration.

Fehlerbehandlung und Logging

Fehler verschlucken ist die häufigste PHP-Sünde. Modernes PHP unterscheidet sauber zwischen Exceptions (programmgesteuert) und Fehlern (Laufzeit):

try {
    $stmt = $pdo->prepare("SELECT * FROM user WHERE id = ?");
    $stmt->execute([$id]);
    $user = $stmt->fetch();
    if (!$user) {
        throw new RuntimeException("User nicht gefunden");
    }
} catch (PDOException $e) {
    error_log("DB-Fehler: " . $e->getMessage());
    http_response_code(500);
    echo json_encode(["error" => "Interner Fehler"]);
}

Wichtig: Dem Nutzer niemals rohe Fehlermeldungen zeigen – die enthüllen Datenbankstruktur und Pfade. In Produktion gilt display_errors=0, alles geht ins Log. Für strukturierte Fehlerüberwachung bieten sich Sentry oder einfache Log-Aggregation an (siehe Monitoring in der Systemadministration).

Gemeinsame Nutzung mit Datenbanken: PDO richtig einsetzen

PDO ist der moderne Datenbank-Zugang (MySQL/MariaDB, PostgreSQL, SQLite). Die wichtigsten Details:

$pdo = new PDO(
    'mysql:host=localhost;dbname=app;charset=utf8mb4',
    $user, $pass,
    [
        PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
        PDO::ATTR_EMULATE_PREPARES   => false,
    ]
);

// Transaktion: entweder alles oder nichts
$pdo->beginTransaction();
try {
    $pdo->exec("UPDATE konto SET saldo = saldo - 100 WHERE id = 1");
    $pdo->exec("UPDATE konto SET saldo = saldo + 100 WHERE id = 2");
    $pdo->commit();
} catch (Throwable $e) {
    $pdo->rollBack();
    throw $e;
}

Transaktionen verhindern, dass bei einem Fehler halbe Buchungen zurückbleiben. ATTR_EMULATE_PREPARES = false nutzt echte Prepared Statements des Servers – schneller und sicherer. Die Grundlagen zu SQL selbst finden Sie im Artikel SQL-Grundlagen.

Fazit

PHP ist 2026 eine pragmatische, gut wartbare Wahl – besonders dort, wo Hosting-Umgebungen vorgegeben sind (Joomla, WordPress) oder schnelle Ergebnisse zählen. Wer moderne Features nutzt, auf Sicherheit achtet und sauber strukturiert, entwickelt damit genauso professionell wie mit jeder anderen Sprache. Die Grundlagen zu SQL-Datenbanken finden sich im Artikel SQL-Grundlagen.

Verwandte Artikel: Python für Einsteiger · SQL-Grundlagen · Systemadministration

Letzte Änderungen