GitHub Actions ist ein Feature von GitHub, mit dem du automatisierte Workflows für deine Softwareprojekte erstellen kannst – direkt im GitHub-Repository.

🛠️ Was kann man mit GitHub Actions machen?

Du kannst CI/CD-Pipelines (Continuous Integration / Continuous Deployment) aufbauen, z. B.:

• ✅ Code automatisch testen (z. B. mit PHPUnit, Jest, Pytest)

• 🛠️ Code bei jedem Push oder Pull Request builden

• 🚀 Software automatisch deployen (z. B. auf einen Webserver, in die Cloud, zu DockerHub)

• 📦 Releases erstellen (z. B. ZIP-Dateien, Versionstags)

• 🔄 Cronjobs oder geplante Tasks laufen lassen

🧱 Wie funktioniert es?

GitHub Actions basiert auf sogenannten Workflows, die du in einer Datei definierst:

• Die Datei heißt z. B. .github/workflows/ci.yml

• Sie ist im YAML-Format

• Du definierst Events (z. B. push, pull_request) und Jobs (z. B. build, test)

• Jobs bestehen aus Steps, die Befehle oder Aktionen ausführen

Beispiel: Einfacher CI-Workflow für Node.js

name: CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '20'
      - run: npm install
      - run: npm test

🧩 Was sind "Actions"?

Eine Action ist ein einzelner Schritt, den man in einem Workflow ausführt. Es gibt:

• Vorgefertigte Actions (z. B. actions/checkout, setup-node, upload-artifact)

• Eigene Actions (z. B. Shell-Skripte oder Docker-Container)

Du kannst Actions im GitHub Marketplace finden und nutzen.

💡 Warum ist das nützlich?

• Spart manuelle Arbeit

• Verbessert Codequalität (durch automatisierte Tests)

• Macht Deployments reproduzierbar

• Alles direkt in GitHub – kein externer CI-Dienst nötig (wie Jenkins oder Travis CI)

Docker Compose ist ein Werkzeug, mit dem du mehrere Docker-Container als einen einzigen Service definieren und starten kannst. Statt jeden Container einzeln über die Docker-CLI zu starten, kannst du mit Docker Compose eine docker-compose.yml-Datei schreiben, in der du alle benötigten Dienste (z. B. Datenbank, Webserver, App-Container) deklarierst.

Kurz gesagt:

Docker Compose = Projektbeschreibung + Mehrere Container + Ein Befehl zum Starten

Beispiel: docker-compose.yml

version: '3.9'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/code
  redis:
    image: "redis:alpine"

In diesem Beispiel:

• Ein Container baut die lokale Webanwendung.

• Ein zweiter Container nutzt das offizielle Redis-Image.

• Beide Container sind miteinander vernetzt.

Häufige Kommandos:

docker-compose up       # Startet alle Container im Vordergrund
docker-compose up -d    # Startet im Hintergrund (detached)
docker-compose down     # Stoppt und entfernt Container, Netzwerke etc.

Vorteile von Docker Compose:

✅ Einfaches Setup für Multi-Container-Anwendungen
✅ Alles wird in einer Datei versioniert (z. B. für Git)
✅ Reproduzierbare Entwicklungsumgebungen
✅ Leichtes Hoch- und Runterfahren ganzer Stacks

Typische Anwendungsfälle:

• Lokale Entwicklung mit mehreren Services (z. B. App + DB)

• Integrationstests mit vollständigem Stack

• Simpler Deployment-Workflow (z. B. über CI/CD)

Contentful ist ein sogenanntes Headless Content Management System (Headless CMS). Es ermöglicht Unternehmen, Inhalte (Content) zentral zu verwalten und flexibel über APIs an verschiedene Ausgabekanäle auszuliefern – z. B. Websites, Apps oder digitale Displays.

Was bedeutet „Headless“?

Traditionelle CMS (wie WordPress) verwalten Inhalte und präsentieren sie gleichzeitig auf einer fest verknüpften Website. Bei einem Headless CMS ist die „Präsentationsschicht“ (Frontend) vom „Content-Management“ (Backend) getrennt. Man hat also nur den „Kopf“ (Frontend) abgetrennt – daher der Begriff „headless“.

Hauptmerkmale von Contentful:

• API-first: Inhalte werden über REST oder GraphQL APIs bereitgestellt.

• Flexibles Content Modeling: Man definiert eigene Content-Typen (z. B. Blogartikel, Produkte, Testimonials) mit frei wählbaren Feldern.

• Mehrsprachigkeit: Gute Unterstützung für mehrsprachige Inhalte.

• Cloud-basiert: Keine eigene Server-Infrastruktur nötig.

• Integration: Lässt sich gut mit Tools wie React, Vue, Next.js, Shopify, SAP, etc. kombinieren.

Für wen ist Contentful interessant?

• Unternehmen mit mehreren Ausgabekanälen (Website, App, Smartwatch, etc.)

• Teams, die Frontend und Backend getrennt entwickeln wollen

• Große Marken mit internationaler Präsenz

• Entwicklerteams, die ein flexibles und skalierbares CMS suchen

Ein Prepared Statement (auch vorbereitetes Statement genannt) ist eine Technik in der Programmierung, insbesondere bei der Arbeit mit Datenbanken, um SQL-Abfragen sicherer und effizienter auszuführen.

1. Was passiert bei einem Prepared Statement?

Ein Prepared Statement besteht aus zwei Schritten:

1. Vorbereitung der SQL-Abfrage mit Platzhaltern
   Beispiel in SQL:

SELECT * FROM users WHERE username = ? AND password = ?

• (In manchen Sprachen nutzt man auch :username oder andere Platzhalter)

• Bindung der Parameter und Ausführung
  Die echten Werte werden später „gebunden“, z. B.:

$stmt->bind_param("ss", $username, $password);
$stmt->execute();

2. Vorteile

✅ Sicherer vor SQL-Injection:
Benutzereingaben werden nicht direkt in die SQL eingebaut, sondern separat behandelt.

✅ Schneller bei Wiederholungen:
Die SQL-Abfrage wird vom Datenbankserver einmal geparst und kann mehrfach effizient ausgeführt werden (z. B. bei Schleifen).

$conn = new mysqli("localhost", "user", "pass", "database");
$stmt = $conn->prepare("SELECT * FROM users WHERE email = ?");
$stmt->bind_param("s", $email); // "s" für string
$email = "beispiel@example.com";
$stmt->execute();
$result = $stmt->get_result();

Kurz gesagt:

Ein Prepared Statement trennt SQL-Logik von Benutzereingaben und schützt so vor Sicherheitslücken wie SQL-Injection. Es ist eine Best Practice beim Umgang mit Datenbanken.

Ein Entity Manager ist ein zentraler Bestandteil von ORM-Frameworks (Object-Relational Mapping), vor allem im Zusammenhang mit Java (JPA – Java Persistence API), aber auch in anderen Sprachen wie PHP (Doctrine ORM).

Hier ist eine verständliche Erklärung:

💡 Definition:

Ein Entity Manager ist eine Komponente, die sich um die Verwaltung von Datenbank-Entities (also Objekten/Datensätzen) kümmert. Er bildet die Schnittstelle zwischen der objektorientierten Welt des Codes und der relationalen Welt der Datenbank.

📦 Aufgaben eines Entity Managers:

1. Persistieren (Speichern):

   • Speichert ein neues Objekt (Entity) in der Datenbank.

   • Beispiel: $entityManager->persist($user);

2. Finden/Laden:

   • Holt ein Objekt anhand seiner ID oder anderer Kriterien.

   • Beispiel: $entityManager->find(User::class, 1);

3. Aktualisieren:

   • Änderungen an einem Objekt werden verfolgt und in die Datenbank geschrieben (z. B. beim flush()).

4. Entfernen/Löschen:

   • Löscht ein Objekt aus der Datenbank.

   • Beispiel: $entityManager->remove($user);

5. Transaktionen verwalten:

   • Beginnt, commitet oder rollt Transaktionen zurück.

6. Query-Handling:

   • Führt eigene Abfragen aus, oft mit DQL (Doctrine Query Language) oder JPQL.

🔁 Lebenszyklus von Entities:

Der Entity Manager verwaltet den „Zustand“ von Objekten:

• managed (verfolgt Änderungen),

• detached (nicht mehr verwaltet),

• removed (zum Löschen markiert),

• new (noch nicht gespeichert).

🛠 Beispiel mit Doctrine (PHP):

$user = new User();
$user->setName('Max Mustermann');

$entityManager->persist($user); // Zum Speichern vormerken
$entityManager->flush();        // Tatsächlich in DB schreiben

Fazit:

Der Entity Manager ist der zentrale Ansprechpartner, wenn es darum geht, mit Datenbankobjekten zu arbeiten – lesen, schreiben, ändern, löschen. Er abstrahiert die SQL-Ebene und macht die Datenbankarbeit objektorientiert steuerbar.

Ein Join Point ist ein Begriff aus der Aspect-Oriented Programming (AOP), also der aspektorientierten Programmierung.

Definition:

Ein Join Point ist eine definierte Stelle im Ablauf eines Programms, an der zusätzlicher Code (ein sogenannter Aspekt) eingefügt werden kann.

Typische Beispiele für Join Points:

• Aufruf einer Methode

• Ausführung einer Methode

• Zugriff auf ein Attribut (lesen oder schreiben)

• Werfen einer Ausnahme

Kontext:

In AOP wird Programmcode modularisiert, indem Querschnittsfunktionen (wie Logging, Sicherheit, Transaktionsmanagement) aus dem eigentlichen Anwendungscode ausgelagert werden. Diese Funktionen werden dann an bestimmten Punkten im Programmablauf (den Join Points) „eingeschnitten“.

Weitere Begriffe im Zusammenhang:

• Pointcut: Eine Ausdrucksweise, mit der beschrieben wird, welche Join Points betroffen sind (z. B. „alle Methoden mit dem Namen save*“).

• Advice: Der Code, der an einem Join Point ausgeführt wird (z. B. „logge diesen Methodenaufruf“).

• Aspect: Eine Kombination aus Pointcut(s) und Advice(s) – also ein vollständiges Modul, das eine Querschnittsfunktion implementiert.

Beispiel (in Spring AOP):

@Before("execution(* com.example.service.*.*(..))")
public void logBeforeMethod(JoinPoint joinPoint) {
    System.out.println("Aufruf von: " + joinPoint.getSignature().getName());
}

→ Hier wird vor jedem Methodenaufruf in einem bestimmten Package ein Logging-Code ausgeführt – und joinPoint.getSignature() liefert Details zum konkreten Join Point.

Aspect-Oriented Programming (AOP) ist ein Programmierparadigma, das sich darauf konzentriert, Querschnittsfunktionen (Cross-Cutting Concerns) modular zu kapseln. Es ergänzt objektorientierte oder funktionale Programmierung, indem es Code, der sich durch viele Klassen oder Module zieht, auslagert und separat behandelt.

💡 Ziel:

Probleme wie Logging, Sicherheitsprüfungen, Fehlerbehandlung, Transaktionsmanagement oder Performance-Messungen sind typische Cross-Cutting Concerns. Diese wiederholen sich oft in vielen Klassen und Methoden – AOP ermöglicht es, solchen Code zentral zu schreiben und automatisch an den richtigen Stellen auszuführen.

🔧 Grundbegriffe:

• Aspect: Ein Modul, das eine Querschnittsfunktion kapselt.

• Advice: Der eigentliche Code, der ausgeführt wird (z. B. vor, nach oder anstatt einer Methode).

• Join Point: Ein Punkt im Programmablauf, an dem ein Aspect eingreifen kann (z. B. Methodenaufruf).

• Pointcut: Eine Definition, welche Join Points betroffen sind (z. B. "alle Methoden in Klasse X").

• Weaving: Der Prozess, bei dem Aspect-Code mit dem eigentlichen Code „verwoben“ wird – zur Laufzeit, beim Kompilieren oder beim Laden.

🛠 Beispiel (in Java mit Spring AOP):

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Methode wird aufgerufen: " + joinPoint.getSignature().getName());
    }
}

Dieser Code führt automatisch Logging aus, bevor jede Methode im com.example.service-Paket ausgeführt wird.

✅ Vorteile:

• Bessere Modularität

• Weniger Code-Duplikate

• Trennung von Fachlogik und Querschnittslogik

❌ Nachteile:

• Kann die Lesbarkeit erschweren (man sieht nicht sofort, was alles beim Methodenaufruf passiert).

• Debugging kann komplexer sein.

• Oft framework-abhängig (z. B. Spring, AspectJ).

Assertions (auf Deutsch: Behauptungen oder Zusicherungen) sind Programmierkonstrukte, mit denen du Annahmen über den Zustand deines Programms überprüfst. Eine Assertion prüft, ob eine bestimmte Bedingung wahr ist – wenn nicht, wird typischerweise ein Fehler ausgelöst und das Programm abgebrochen.

Beispiel (in Python):

x = 10
assert x > 0   # läuft problemlos
assert x < 5   # AssertionError, weil x nicht kleiner als 5 ist

Zweck von Assertions:

• Sie helfen beim Debuggen: Du überprüfst, ob bestimmte Voraussetzungen im Code erfüllt sind.

• Sie dokumentieren implizite Annahmen: z. B. „An dieser Stelle muss die Liste mindestens ein Element haben.“

• Sie dienen der Fehlersuche in der Entwicklungsphase – im Produktivcode werden sie oft deaktiviert.

Wichtiger Unterschied zu regulären Fehlerbehandlungen:

Assertions sollen Programmfehler aufdecken, nicht Benutzereingaben oder äußere Einflüsse abfangen. Beispiel:

• assert age > 0 → falsch, wenn age aus Benutzereingabe stammt.

• Stattdessen: if age <= 0: raise ValueError("Alter muss positiv sein.")

Design by Contract (DbC) ist ein Konzept aus der Softwareentwicklung, das von Bertrand Meyer eingeführt wurde. Es beschreibt eine Methode zur Sicherstellung der Korrektheit und Zuverlässigkeit von Software, indem Verträge zwischen den verschiedenen Komponenten (z.B. Methoden, Klassen) definiert werden.

Grundprinzipien von Design by Contract

Bei DbC wird jede Software-Komponente wie eine Vertragspartei gesehen, die bestimmte Verpflichtungen und Garantien einhält:

1. Vorbedingungen (Preconditions)
   Bedingungen, die erfüllt sein müssen, bevor eine Methode oder Funktion korrekt ausgeführt werden kann.
   → Verantwortung des Aufrufers.

2. Nachbedingungen (Postconditions)
   Bedingungen, die nach der Ausführung garantiert werden.
   → Verantwortung der Methode/Funktion.

3. Invariant (Klasseninvariante)
   Bedingungen, die während der gesamten Lebenszeit eines Objekts wahr bleiben müssen.
   → Verantwortung sowohl der Methode als auch des Aufrufers.

Ziel von Design by Contract

• Klare Spezifikation der Verantwortlichkeiten.

• Robustere und besser testbare Software.

• Fehler werden frühzeitig erkannt (z.B. durch Verletzung des Vertrags).

Beispiel in Pseudocode

class BankAccount {
    private double balance;

    // Invariante: balance >= 0

    void withdraw(double amount) {
        // Vorbedingung: amount > 0 && amount <= balance
        if (amount <= 0 || amount > balance) throw new IllegalArgumentException();

        balance -= amount;

        // Nachbedingung: balance wurde um amount verringert
    }
}

Vorteile

• Klare Verträge führen zu weniger Missverständnissen.

• Bessere Fehlersuche, da Verstöße gegen Verträge sofort auffallen.

• Unterstützt die defensive Programmierung.

Nachteile

• Erhöhter Aufwand in der Spezifikation.

• Nicht von allen Programmiersprachen direkt unterstützt (z.B. Java, C++ über Assertions, Python mit Decorators; Eiffel unterstützt DbC nativ).

Perl Compatible Regular Expressions (PCRE) sind eine Implementierung von regulären Ausdrücken, die sich an der Syntax und Funktionalität der Programmiersprache Perl orientiert. Sie bieten eine sehr mächtige, flexible und erweiterte Syntax, die über einfache reguläre Ausdrücke hinausgeht.

Warum „Perl Compatible“?

Perl war eine der ersten Sprachen, die besonders leistungsstarke reguläre Ausdrücke eingeführt hat. Die PCRE-Bibliothek wurde entwickelt, um diese Funktionen auch in anderen Programmiersprachen und Tools verfügbar zu machen – zum Beispiel in:

• PHP

• Python (teilweise, re-Modul ähnelt PCRE)

• JavaScript (mit leichten Abweichungen)

• grep-Varianten wie pcregrep

• Texteditoren wie VS Code, Sublime Text etc.

Wichtige Features von PCRE:

✅ Lookahead & Lookbehind:

• (?=...) – positive Lookahead

• (?!...) – negative Lookahead

• (?<=...) – positive Lookbehind

• (?<!...) – negative Lookbehind

✅ Nicht-gierige Quantifizierer:

• *?, +?, ??, {m,n}?

✅ Benannte Gruppen:

• (?P<name>...) oder (?<name>...)

✅ Unicode-Support:

• \p{L} für Unicode-Buchstaben usw.

✅ Assertions und Grenzen:

• \b, \B, \A, \Z, \z

✅ Modifikatoren:

• (?i) für case-insensitive

• (?m) für multiline usw.

(?<=\buser\s)\w+

Dieser Ausdruck findet Wörter, die nach "user " stehen (Lookbehind).

Fazit:

PCRE sind die "Deluxe-Version" regulärer Ausdrücke – sie sind leistungsfähig, weit verbreitet und flexibel. Wenn du in einem Tool oder einer Sprache arbeitest, die „PCRE unterstützt“, kannst du dich auf die mächtige Perl-ähnliche Syntax freuen.