create a new branch on git

Wer zum ersten Mal in einem Team an Software arbeitet, merkt schnell: Ohne Struktur brennt die Hütte. Ich habe Projekte gesehen, in denen Entwickler direkt auf dem Hauptzweig gearbeitet haben. Das Ergebnis war pures Chaos. Git ist dein Sicherheitsnetz, aber nur, wenn du weißt, wie man die Seile spannt. Wenn du vorhast, Create A New Branch On Git zu einer Routine in deinem Workflow zu machen, musst du die Mechanik dahinter verstehen. Ein Zweig ist in Git nichts weiter als ein beweglicher Zeiger auf einen bestimmten Commit. Das klingt simpel. Trotzdem verbringen Teams Stunden damit, Merge-Konflikte zu lösen, die vermeidbar gewesen wären. In diesem Artikel räumen wir mit Halbwissen auf. Wir schauen uns an, wie man isolierte Umgebungen schafft, ohne den Überblick zu verlieren.

Die Philosophie hinter dem Verzweigen

In der klassischen Softwareentwicklung gab es früher starre Zyklen. Man hat Wochen gewartet, bis Code integriert wurde. Mit Git hat sich das geändert. Heute erstellen wir für jede Kleinigkeit einen neuen Pfad. Das ist gut so. Ein Zweig erlaubt dir, zu experimentieren. Wenn dein Experiment scheitert, löschst du den Zweig einfach. Der restliche Code bleibt sauber. Viele Anfänger haben Angst, etwas kaputt zu machen. Aber genau dafür ist diese Funktion da. Du isolierst deine Arbeit.

Stell dir vor, du arbeitest an einer neuen Bezahlfunktion für einen Onlineshop. Gleichzeitig meldet ein Kunde einen kritischen Fehler im Warenkorb. Wenn du keinen eigenen Bereich für deine Bezahlfunktion hast, steckt dein unfertiger Code im System fest. Du kannst den Fehler nicht beheben, ohne deinen halbfertigen, kaputten Code mit auszuliefern. Das ist der Moment, in dem die Panik aufsteigt. Mit einer sauberen Trennung wechselst du einfach zurück zum stabilen Stand, fixst das Problem und kehrst danach zu deiner Baustelle zurück.

Warum Namen wichtiger sind als Technik

Ein großer Fehler ist die schlechte Benennung. Ich habe Repositories gesehen, da hießen die Zweige "test", "fix1" oder "mein-code". Das hilft niemandem. Nach zwei Wochen weißt du selbst nicht mehr, was du da eigentlich gemacht hast. Ein guter Name folgt einem Muster. Viele Teams nutzen Präfixe wie feature/, bugfix/ oder hotfix/.

Wenn du an der Benutzeroberfläche arbeitest, nenne den Zweig feature/login-button-styling. Das ist klar. Jeder im Team sieht sofort, worum es geht. Es spart Kommunikation. In großen Open-Source-Projekten ist das Standard. Schau dir die Dokumentation von Git an, dort wird deutlich, wie zentral diese Konzepte für die Integrität des Projekts sind.

Create A New Branch On Git und die verschiedenen Befehle

Es gibt nicht nur den einen Weg, um einen neuen Arbeitsbereich zu erstellen. Früher haben wir alle git branch benutzt. Das funktioniert immer noch. Aber es ist ein zweistufiger Prozess. Du erstellst den Zweig und musst dann aktiv dorthin wechseln. Das ist nervig. Mittlerweile gibt es modernere Befehle, die das kombinieren.

Der Klassiker ist git checkout -b name-des-zweigs. Das erledigt zwei Aufgaben auf einmal. Es legt den Zweig an und schiebt dich direkt hinein. Seit Git Version 2.23 gibt es zudem git switch -c. Dieser Befehl ist intuitiver. Das Wort "checkout" war für viele Neulinge verwirrend, weil es zu viele Funktionen gleichzeitig abdeckte. "Switch" sagt genau das aus, was passiert: Du wechselst den Kontext.

Der Unterschied zwischen lokalen und entfernten Zweigen

Ein Punkt, der oft für Verwirrung sorgt, ist die Synchronisation. Nur weil du lokal auf deinem Rechner einen neuen Pfad angelegt hast, weiß der Server davon noch nichts. Dein GitHub- oder GitLab-Repository bleibt unverändert. Das ist ein wichtiger Schutzmechanismus. Du kannst lokal so viel Chaos anrichten, wie du willst.

Erst wenn du bereit bist, teilst du deine Arbeit. Dafür nutzt du den Push-Befehl. Beim ersten Mal musst du Git sagen, wo dieser neue Zweig auf dem Server landen soll. Meistens nutzt man dafür den Parameter --set-upstream. Damit verknüpfst du dein lokales Abbild mit dem auf dem Server. Ab diesem Moment können deine Kollegen sehen, woran du arbeitest. Sie können deinen Stand herunterladen und Feedback geben.

Arbeiten mit Headless States

Manchmal landet man in einem Zustand, den Git "detached HEAD" nennt. Das passiert, wenn du direkt zu einem Commit springst, statt einen Zweig zu nutzen. Das ist gefährlich. Wenn du dort Änderungen machst und dann wegwechselst, gehen deine Änderungen verloren. Sie hängen im luftleeren Raum. Um das zu vermeiden, solltest du immer einen Zeiger erstellen. Falls du dich doch mal in diesem Zustand wiederfindest, kannst du mit Create A New Branch On Git deinen aktuellen Stand retten und ihm einen Namen geben.

Strategien für erfolgreiche Teamarbeit

Es reicht nicht, die Befehle zu kennen. Du brauchst einen Plan. In der Branche haben sich verschiedene Workflows etabliert. Einer der bekanntesten ist Git Flow. Hier gibt es strikte Regeln, welche Art von Zweig wohin gemergt werden darf. Es gibt einen Zweig für die Entwicklung und einen für die Veröffentlichung. Das ist sicher, aber oft zu langsam für kleine Teams.

Eine Alternative ist das Trunk-Based Development. Hier leben Zweige nur sehr kurz. Man erstellt sie, implementiert eine kleine Funktion und führt sie sofort wieder mit dem Hauptstrang zusammen. Das erfordert Disziplin und gute automatisierte Tests. Aber es verhindert die gefürchtete "Merge-Hölle", in der man tagelang Konflikte lösen muss, weil sich die Codebasis in der Zwischenzeit zu stark verändert hat.

Merge gegen Rebase

Das ist fast schon eine religiöse Debatte unter Entwicklern. Beim Mergen behältst du die komplette Historie. Man sieht genau, wann welcher Zweig abgegangen ist und wann er zurückkam. Das kann unübersichtlich werden. Das Ergebnis sieht oft aus wie ein wirres U-Bahn-Netz.

Rebase hingegen schreibt die Geschichte neu. Es nimmt deine Änderungen und setzt sie oben auf den aktuellen Stand des Hauptzweigs drauf. Das Ergebnis ist eine saubere, lineare Historie. Es sieht so aus, als hättest du deine Arbeit gerade erst begonnen, obwohl du vielleicht Tage daran gesessen hast. Aber Vorsicht: Rebase darf man niemals auf Zweigen machen, die bereits öffentlich geteilt wurden. Damit würdest du die Geschichte für deine Kollegen zerstören. Wer mehr über die technischen Hintergründe von Commit-Graphen erfahren möchte, findet beim Hasso-Plattner-Institut oft tiefgehende Materialien zu Datenstrukturen.

Die Rolle von Pull Requests

Ein Zweig ist oft die Basis für einen Pull Request oder Merge Request. Hier findet die eigentliche Qualitätskontrolle statt. Du sagst: "Ich bin fertig, bitte schau dir das mal an." Deine Kollegen können Zeile für Zeile kommentieren. Das verbessert den Code enorm. Es geht nicht darum, Fehler zu suchen, sondern Wissen zu teilen.

Ein guter Pull Request sollte klein sein. Niemand hat Lust, 50 geänderte Dateien zu prüfen. Wenn du deine Zweige klein hältst, bekommst du schneller Feedback. Deine Arbeit fließt zügiger in das Hauptprodukt ein. Das motiviert. Große Monster-Zweige hingegen bleiben oft tagelang liegen, weil jeder im Team die Sichtung vor sich herschiebt.

Typische Fehler und wie man sie behebt

Jeder macht Fehler. Das gehört dazu. Einer der häufigsten Fauxpas ist das Arbeiten im falschen Zweig. Du fängst an zu tippen und merkst nach zehn Minuten: Mist, ich bin noch auf dem main. Kein Problem. Git hat dafür den "Stash". Du legst deine Änderungen kurz auf die Seite, wechselst in den richtigen Bereich oder erstellst einen neuen und holst die Änderungen wieder hervor.

Ein anderes Problem sind vergessene Zweige. Nach ein paar Monaten hat dein Projekt 50 verwaiste Pfade. Das macht das Repository langsam und unübersichtlich. Gewöhne dir an, Zweige nach dem Mergen sofort zu löschen. Sowohl lokal als auch auf dem Server. Die Commits gehen dadurch nicht verloren, sie sind ja jetzt im Hauptstrang integriert.

Konflikte sind keine Katastrophe

Wenn zwei Leute die gleiche Zeile in der gleichen Datei ändern, knallt es. Git weiß nicht, welche Version die richtige ist. Viele Anfänger bekommen hier Schweißausbrüche. Aber eigentlich ist das nur ein Hinweis von Git: "Entscheide du bitte."

In modernen Editoren wie VS Code werden Konflikte grafisch aufbereitet. Du klickst einfach an, ob du Version A, Version B oder beide behalten willst. Danach speicherst du und schließt den Vorgang ab. Je öfter du den Hauptzweig in deinen Arbeitszweig ziehst, desto seltener werden diese Konflikte. Es ist wie beim Aufräumen: Wenn man es täglich macht, dauert es nur Minuten. Wartet man einen Monat, braucht man ein ganzes Wochenende.

Die Gefahr von Force Push

Es gibt diesen einen Befehl, der alles zerstören kann: git push --force. Damit sagst du dem Server: "Ignoriere alles, was du weißt, mein Stand ist das Gesetz." Wenn ein Kollege in der Zwischenzeit etwas hochgeladen hat, ist seine Arbeit weg. Gelöscht. Überschrieben.

Nutze Force Push nur auf deinen eigenen, privaten Zweigen, an denen niemand sonst arbeitet. Und selbst dann ist --force-with-lease die bessere Wahl. Dieser Befehl prüft vorher, ob sich auf dem Server etwas getan hat, das du noch nicht auf deinem Rechner hast. Es ist die Sicherung für die Sicherung.

Automatisierung und Tools

Man muss Git nicht komplett auf der Kommandozeile bedienen. Es hilft zwar, die Grundlagen zu kennen, aber im Alltag sind GUI-Tools Gold wert. Programme wie GitKraken oder Tower visualisieren den Baum. Du siehst sofort, wo welcher Zweig steht.

Besonders nützlich sind diese Tools, wenn es um komplexe Operationen wie Cherry-Picking geht. Dabei nimmst du nur einen einzelnen Commit aus einem anderen Zweig und kopierst ihn in deinen aktuellen. Das ist praktisch, wenn du einen Bugfix aus einem experimentellen Zweig sofort im stabilen System brauchst, ohne den Rest des Experiments mitzunehmen.

Hooks und CI/CD

Ein moderner Workflow geht über das reine Erstellen von Zweigen hinaus. Mit Git Hooks kannst du Skripte ausführen, die jedes Mal starten, wenn du einen neuen Pfad anlegst oder Code committest. Du kannst zum Beispiel automatisch prüfen lassen, ob dein Code den Formatierungsregeln entspricht.

Sobald du deinen Zweig auf den Server schiebst, springt oft die CI/CD-Pipeline an. GitHub Actions oder GitLab CI bauen das Projekt und lassen alle Tests laufen. Wenn eine rote Ampel leuchtet, weißt du sofort: In diesem Zweig ist etwas kaputt. Das gibt dir die Freiheit, mutig zu sein. Du weißt, dass das System dich warnt, bevor dein Fehler den Hauptzweig erreicht. Informationen zu sicherem Code und Standards findest du auch beim Bundesamt für Sicherheit in der Informationstechnik.

Die psychologische Komponente

Softwareentwicklung ist Teamwork. Ein Zweig ist auch ein Kommunikationsmittel. Er signalisiert den Kollegen: "Ich kümmere mich gerade um das Problem mit den Bildern." Das verhindert doppelte Arbeit. In einem guten Team schaut man morgens kurz in die Liste der aktiven Zweige. So weiß jeder, was gerade passiert, ohne dass man lange Meetings abhalten muss.

Es nimmt auch den Druck. Wenn du weißt, dass deine Arbeit in einem sicheren Container lebt, traust du dich eher, radikale Ideen auszuprobieren. Die besten Innovationen entstehen oft in Zweigen, die eigentlich nur zum "Spielen" gedacht waren. Am Ende war die Idee so gut, dass sie doch den Weg in das fertige Produkt gefunden hat.

Praktische Schritte für deinen Workflow

Du hast jetzt die Theorie im Kopf. Jetzt geht es an die Umsetzung. Theorie ohne Praxis ist in der IT wertlos. Hier ist dein Fahrplan für die nächsten Schritte:

1. Prüfe deinen aktuellen Status. Bevor du startest, stelle sicher, dass deine lokale Kopie sauber ist. Nutze git status. Wenn dort noch ungespeicherte Änderungen liegen, committe sie oder nutze den Stash.
2. Aktualisiere deinen Hauptzweig. Hole dir die neuesten Änderungen vom Server mit git pull. Du willst deine neue Arbeit auf dem aktuellsten Fundament aufbauen.
3. Erstelle deinen neuen Arbeitsbereich. Nutze einen klaren Namen mit Präfix, zum Beispiel feature/neue-suche. Verwende dafür den Befehl git switch -c feature/neue-suche.
4. Arbeite in kleinen Etappen. Mache häufige Commits mit aussagekräftigen Nachrichten. Warte nicht bis zum Feierabend, um alles auf einmal zu speichern.
5. Teile deine Arbeit frühzeitig. Auch wenn du noch nicht fertig bist, schiebe den Zweig auf den Server. Das dient als Backup und erlaubt Kollegen, frühzeitig reinzuschauen.
6. Wenn die Aufgabe erledigt ist, erstelle einen Pull Request. Lass deinen Code prüfen. Sei offen für Kritik.
7. Nach dem erfolgreichen Zusammenführen löschst du den Zweig lokal und auf dem Server. Halte dein System sauber.

Das Beherrschen dieser Abläufe unterscheidet Hobby-Programmierer von Profis. Es geht nicht darum, möglichst viele Befehle auswendig zu kennen. Es geht darum, einen Prozess zu haben, dem man vertrauen kann. Wenn du das nächste Mal vor einer neuen Aufgabe stehst, nimm dir die Sekunde Zeit für die Struktur. Dein zukünftiges Ich wird es dir danken, wenn es drei Monate später versucht zu verstehen, was du damals eigentlich getrieben hast. Ein sauberer Git-Verlauf ist wie ein gut geführtes Tagebuch deiner Entwicklung.