Git - Intensiv Workshop in Köln

• 1. Einführung: Konzepte statt Kommandos
  • Warum Git anders unterrichtet werden sollte: Konzepte vor Kommandos
  • Die Philosophie hinter Git: Dezentral, verteilt, datenintegriert
  • Überblick: Was werden wir in den drei Tagen lernen?
  • Grundlegende Konfiguration: Benutzername und E-Mail einrichten

• 2. Lokale Git-Architektur verstehen: Die drei Bereiche
  • Working Copy, Staging Area (Index) und Local Repository
  • Visuelles Modell: Wo befinden sich Änderungen zu welchem Zeitpunkt?
  • git init: Ein neues Repository erstellen
  • git add: Änderungen zum Speichern vormerken
  • git commit: Änderungen im Local Repository persistent speichern
  • Die verschiedenen Zustände von Dateien: Untracked, Modified, Staged, Committed
  • Der Unterschied zwischen Local und Remote Repository
  • Git merkt sich lokal den Stand der Remote-Repositories
  • Wichtige Erkenntnis: Fast alles in Git ist lokal
  • Praktische Übung: Erste Schritte mit init, add, commit

• 3. Commit Etiquette: Gute Commit-Messages schreiben
  • Was gehört in eine gute Commit-Message?
  • Struktur: Subject, Body, Footer
  • Conventional Commits als Standard
  • Warum sind aussagekräftige Commit-Messages wichtig?
  • Praktische Übung: Gute Commit-Messages schreiben

• 4. Entfernte Git-Architektur verstehen: Remote Repositories
  • Ein Remote ist auch nur ein weiteres Repository
  • git remote: Ein Remote-Repository einrichten
  • git push: Änderungen zu einem Remote-Repository senden
  • git fetch: Änderungen von einem Remote-Repository holen
  • git pull: Änderungen von einem Remote-Repository holen und integrieren
  • Wann Fetch statt Pull?
  • Remote-Tracking-Branches: origin/main vs. main
  • git clone: Sich ein Repository besorgen
  • Praktische Übung: Fetch und Pull im Detail beobachten

• 5. Forensik: Die aktuellen Änderungen und die Historie untersuchen
  • git status: Den aktuellen Zustand verstehen
  • git diff: Änderungen im Detail betrachten
  • git show: Einzelne Commits analysieren
  • git log und seine Optionen
  • Visualisierung der Commit-History
  • Änderungen zwischen Commits vergleichen
  • Praktische Übung: Änderungen untersuchen und verstehen

• 6. Branches: Isolierte Entwicklungslinien
  • Branches als isolierte Entwicklungslinien
  • Erlaubt gleichzeitiges Arbeiten an Features und Bugfixes
  • Branches anlegen und verwalten: git branch, git checkout, git switch
  • Branches wieder zusammenführen: git merge
  • Praktische Übung: Branches erstellen, wechseln und mergen

• Tag 2: Remote-Repositories, Branches und Merging
• 7. Blick unter die Haube: Wie Git Daten speichert & organisiert
  • Praktische Exploration: Das .git-Verzeichnis (objects, refs, HEAD, config, hooks)
  • Objects - die Datenstrukturen von Git: Commits, Trees, Blobs
  • Die Commit-History als gerichteter azyklischer Graph (DAG)
  • SHA-1-Hashes: Warum Hashes statt Sequenznummern?
  • HEAD: Wo befinde ich mich gerade?
  • Visualisierung: HEAD -> refs/heads/main -> Commit -> Tree -> Blobs
  • Branches und Tags als Zeiger auf Commits
  • Refs
  • Demo: Mit Low-Level-Kommandos (cat-file, hash-object) Git-Internals erkunden
  • git checkout / git switch: Was passiert beim Branch-Wechsel?

• 8. git merge: Mergen detailliert verstehen
  • Fast-Forward-Merge vs. Three-Way-Merge
  • Wann und wann nicht Fast-Forward-Merges erstrebenswert sind
  • Der Merge-Algorithmus im Detail
  • Visualisierung verschiedener Merge-Szenarien
  • Wann entstehen Konflikte? Wie kann ich sie gezielt vermeiden?
  • Welche Situationen kann Git selbstständig lösen?
  • Anatomie eines Konflikts
  • Konfliktauflösung Schritt für Schritt
  • Praktische Übung: Mergen mit Konflikten

• 9. Rebase als Alternative zum Merge
  • Was ist Rebasing und wie funktioniert es?
  • Warum Rebase? Wann ist es sinnvoll?
  • Rebase vs. Merge: Vor- und Nachteile
  • Die goldene Regel: Niemals gepushte Commits rebasen
  • Praktische Übung: Rebase vs. Merge vergleichen

• 10. Undo-Rezepte: Fehler beheben nach Eskalationsgrad
  • Allgemein: Häufige Fallen und wie man sie vermeidet
  • Stufe 1: Änderungen in der Working Copy rückgängig machen
    • git restore, git checkout

  • Stufe 2: Änderungen aus der Staging Area zurücknehmen
    • git restore --staged, git reset

  • Stufe 3: Einen Commit rückgängig machen (lokal)
    • git reset --soft, --mixed, --hard

  • Stufe 4: Einen Commit nachbessern (lokal)
    • git commit --amend

  • Stufe 5: Mehrere Commits zusammenfassen (lokal)
    • Interactive Rebase, Squash

  • Stufe 6: Einen Commit rückgängig machen (remote/public)
    • git revert

  • Stufe 7: Kaputtes Repository retten
    • git reflog und Recovery-Strategien

• Tag 3: Git im Team, Workflows und Undo-Strategien
• 11. Workflows: Vom Chaos zur Ordnung
  • Criss-Cross-Merge: Warum mergt man nicht nach Bedarf jeder von jedem?
  • Git Workflows: Warum Disziplin und Reihenfolge wichtig sind
  • Central/SVN-Workflow: Probleme und Limitierungen
    • Einfachstmöglicher (Un)-Workflow
    • Nadelöhr-Problem beim Push: Wer zuerst kommt, mahlt zuerst
    • Russisch Roulette beim Pull

  • Praktische Übung: Central-Workflow und seine Probleme erleben
• 12. GitHub-/GitLab-Flow: Pull/Merge-Requests
  • Branches als Snapshot-Isolation
  • Feature-Branches: Konzept und Motivation
  • Was sind Pull/Merge-Requests?
  • Code-Review-Prozess
  • Vom Feature-Branch zum Merge-Request
  • Best Practices für Code-Reviews
  • Praktische Übung: Vollständiger PR-Workflow in GitLab

• 13. Release-Management mit Git
  • Versionierung mit Tags
  • Semantic Versioning: major.minor.patch
  • Feature Freeze und Release Branches
  • Release Notes automatisch generieren mit git log
  • Ausblick: Conventional Commits & semantic-release für automatische Versionierung

• 14. Der komplette Entwicklungszyklus im Überblick
  • Von der Anforderung bis zum Deployment
  • Issue-Tracking mit GitLab Issues
  • Feature-Branches erstellen
  • Code schreiben und committen
  • Merge-Requests erstellen
  • Code-Reviews durchführen
  • Merge-Konflikte lösen
  • Releases erstellen und taggen

LernzieleNach diesem Workshop verstehen Sie Git nicht nur oberflächlich, sondern kennen die zugrunde liegenden Konzepte und Datenstrukturen. Sie können Git sicher in Ihrem täglichen Entwicklungsprozess einsetzen und haben keine Hemmungen mehr vor komplexeren Operationen wie Rebase oder Reset. Sie verstehen, was bei jedem Git-Kommando tatsächlich passiert, können moderne Team-Workflows umsetzen und wissen, welche Strategien für welche Situation geeignet sind. Sicherheitskopien vor Git-Operationen gehören der Vergangenheit an.ZielgruppenEntwickelnde, die Git von Grund auf lernen oder ihre Kenntnisse vertiefen möchten. Auch für Umsteiger von anderen Versionsverwaltungssystemen (SVN, TFS, CVS) geeignet.Teilnahmevoraussetzungen:Grundlegende Programmierkenntnisse und Vertrautheit mit der Kommandozeile. Erste Berührungspunkte mit Versionsverwaltung sind hilfreich, aber nicht zwingend erforderlich.