Was ist Sourcetree?

Sourcetree ist eine grafische Benutzeroberfläche für Git und Mercurial. Es ermöglicht Dir, Deine Repositories visuell zu verwalten, ohne ständig Befehle in der Konsole eintippen zu müssen. Du kannst Branches erstellen, Merges durchführen, Stashes verwalten oder Rebase-Aktionen starten – alles per Mausklick.

Die wichtigsten Features im Überblick

• Klar strukturierte Oberfläche: Du siehst auf einen Blick, was in Deinem Projekt passiert – von Branches über Commits bis hin zu Merge-Konflikten.
• Branch-Management: Erstelle, verwalte und merge Branches schnell und visuell. Ideal für Feature-Branches und Git-Flow.
• Staging & Commit: Wähle gezielt aus, welche Änderungen Du stagen willst und formuliere Deine Commit-Nachrichten direkt im Interface.
• Submodule-Unterstützung: Auch komplexe Projekte mit Submodulen lassen sich bequem verwalten.
• Integration mit Bitbucket, GitHub & Co.: Repositories lassen sich direkt aus der Cloud klonen und pushen.

Für wen eignet sich Sourcetree?

Sourcetree ist sowohl für Git-Neulinge als auch für erfahrene Entwickler ein nützliches Tool. Anfänger profitieren vom visuellen Feedback, das hilft, Git-Konzepte besser zu verstehen. Profis schätzen die schnelle Übersicht bei komplexen Repositories und die Möglichkeit, Fehlerquellen wie Merge-Konflikte frühzeitig zu erkennen.

Sourcetree vs. Kommandozeile

Die Kommandozeile bleibt weiterhin mächtig – aber nicht jeder braucht oder will sie ständig nutzen. Sourcetree bietet eine komfortable Alternative mit vielen Funktionen, ohne auf Flexibilität zu verzichten. Und wenn Du willst, kannst Du jederzeit auch Shell-Befehle aus dem Tool heraus aufrufen.

Fazit: Effizientes Git-Management mit Stil

Sourcetree ist ein solides, durchdachtes Tool, das Git-Workflows deutlich übersichtlicher macht. Es ist kostenlos, leistungsfähig und erleichtert sowohl den Einstieg in Git als auch die tägliche Arbeit an komplexen Projekten. Wenn Du Deine Git-Repos effizient und visuell verwalten möchtest, solltest Du Sourcetree definitiv ausprobieren.

Der Beitrag Sourcetree – Git-Management mit Komfort erschien zuerst auf CEOsBay.

Was ist Git Flow?

Git Flow ist ein von Vincent Driessen entwickeltes Branching-Modell, das einen klaren Workflow für die Softwareentwicklung mit Git vorgibt. Es definiert bestimmte Branches mit klaren Aufgaben und Regeln für deren Verwendung.

Die Haupt-Branches

1. main (oder master)
   Enthält den jeweils stabilen Code, der jederzeit produktionsbereit ist.
2. develop
   Hier landet der aktuelle Entwicklungsstand. Neue Features werden zuerst in develop integriert und getestet, bevor sie in main gemerged werden.

Unterstützende Branches

Neben main und develop gibt es drei unterstützende Branchtypen:

• Feature-Branches (feature/xyz)
  Für neue Features, die auf develop basieren. Nach Fertigstellung wird der Branch wieder in develop gemerged.
• Release-Branches (release/x.y.z)
  Wenn sich develop in einem stabilen Zustand befindet, wird daraus ein Release-Branch erstellt. Hier werden letzte Anpassungen gemacht (Bugfixes, Dokumentation), bevor der Code in main gemerged und ggf. getaggt wird.
• Hotfix-Branches (hotfix/x.y.z)
  Für schnelle Bugfixes auf der Produktionsversion. Sie basieren direkt auf main und werden nach Behebung auch in develop zurückgeführt.

Warum Git Flow?

Vorteile:

• Strukturierte Arbeitsweise
  Jeder Branch hat einen klar definierten Zweck. Das reduziert Chaos in der Codebasis.
• Paralleles Arbeiten
  Teams können gleichzeitig an verschiedenen Features, Fixes oder Releases arbeiten, ohne sich ständig in die Quere zu kommen.
• Stabilität in Produktion
  Durch getrennte Release- und Hotfix-Branches bleibt der Haupt-Branch stabil und deploymentsicher.
• Versionierung und Nachvollziehbarkeit
  Releases und Fixes lassen sich sauber versionieren und nachvollziehen.

Wann ist Git Flow sinnvoll?

Es eignet sich besonders für Projekte mit:

• regelmäßigen Releases
• mehreren Entwicklern oder Teams
• dedizierten Test- und QA-Phasen
• langfristiger Wartung und Weiterentwicklung

Für kleine Projekte oder Continuous Deployment Workflows kann Git Flow dagegen zu „overhead“ führen. In solchen Fällen lohnt sich ein einfacheres Modell wie GitHub Flow.

Tools & Unterstützung

Es gibt viele Tools, die Git Flow unterstützen, z. B.:

• Die Erweiterung git-flow für die Kommandozeile (brew install git-flow)
  (Siehe hierzu auch meinen Beitrag „Homebrew – Paketmanager für MacOS (oder Linux)„)
• GUI-Tools wie Sourcetree
• CI/CD-Systeme, die auf Branch-Namen reagieren können

Fazit

Git Flow ist ein mächtiges Werkzeug, um Ordnung und Struktur in Softwareprojekte zu bringen. Besonders in Teams schafft es Klarheit, wie und wann Code geschrieben, getestet und ausgeliefert wird. Wer sich einmal an das Modell gewöhnt hat, möchte es meist nicht mehr missen.

Der Beitrag Git Flow – Ein bewährtes Modell für die Zusammenarbeit mit Git erschien zuerst auf CEOsBay.

Was ist der Nix Paketmanager?

Es ist ein funktionaler, deklarativer und deterministischer Ansatz zur Softwareinstallation. Anders als klassische Tools wie apt, yum oder brew speichert Nix Pakete und ihre Abhängigkeiten in isolierten Pfaden, um Konflikte und unerwartetes Verhalten zu vermeiden.

Die zugrunde liegende Sprache Nix erlaubt es, komplexe Entwicklungsumgebungen präzise zu definieren – nachvollziehbar, wiederholbar und versionssicher.

Vorteile: Warum es der potentielle Paketmanager der Zukunft ist

1. Reproduzierbare Builds

Durch die deklarative Konfiguration kannst Du exakt die gleiche Umgebung auf jedem System erstellen – lokal, auf dem Server oder in der Cloud.

2. Isolation und Sicherheit

Alle Pakete werden in isolierten Umgebungen gebaut. Damit verschwinden „It works on my machine“-Probleme endgültig.

3. Rollbacks und atomare Updates

Mit nix-env --rollback kannst Du jederzeit zur vorherigen Version deiner Software zurückkehren – ganz ohne Systemchaos.

4. Mehrere Versionen gleichzeitig nutzen

Du kannst damit problemlos mehrere Versionen eines Tools parallel nutzen – ideal für Tests, Legacy-Support und Toolchains.

5. Kein Root-Zugriff erforderlich

Es arbeitet im User-Space. So kannst Du Software installieren, ohne Administratorrechte zu benötigen oder Dein System zu verändern.

Praxisbeispiel: Temporäre Entwicklungsumgebung mit nix-shell

Mit folgendem Befehl öffnest Du eine temporäre Shell mit Python 3.10 (Siehe auch meinen Beitrag „Python – Die Sprache für schnelle Prototypen, Datenanalyse und künstliche Intelligenz„):

bashKopierenBearbeitennix-shell -p python310

Ohne Installation, ohne Konflikte – ideal für Tests und Skript-Ausführung.

NixOS: Ein Betriebssystem, komplett mit Nix konfiguriert

Neben dem Paketmanager gibt es auch das Linux-System NixOS, das vollständig darüber konfiguriert wird. Hier definierst Du alles – vom Kernel über Netzwerkeinstellungen bis zu Desktop-Umgebungen – in einer zentralen Datei. Das ist Infrastructure as Code auf Systemebene.

Einstieg: Was Du wissen solltest

Der Einstieg in die Nix-Welt kann herausfordernd sein. Die Lernkurve ist steiler und die Dokumentation erfordert oft etwas Geduld. Doch es lohnt sich: Sobald Du es beherrschst, wirst Du kaum zurück wollen.

Tipp: Starte mit nixos.org/learn.html – Dort findest Du interaktive Tutorials und Ressourcen.

Fazit: Für wen lohnt sich der Nix Paketmanager?

Wenn Du

• wiederholbare Builds brauchst,
• Software zuverlässig deployen willst,
• verschiedene Versionen parallel brauchst oder
• deine Entwicklungsumgebung unter Kontrolle halten möchtest,

dann ist der Nix Paketmanager genau das Richtige für dich.

Der Beitrag Nix – Der clevere Weg zur modernen Paketverwaltung erschien zuerst auf CEOsBay.

Was ist ein Generic Code Editor (GCE)?

Ein Generic Code Editor ist ein universeller Code-Editor, der eine Vielzahl von Programmiersprachen unterstützt, ohne sich auf eine bestimmte Umgebung oder Sprache zu spezialisieren. Seine Hauptmerkmale sind:

• Syntax-Highlighting für verschiedene Sprachen
• Autovervollständigung für besseren Workflow
• Erweiterbarkeit durch Plugins
• Plattformunabhängigkeit für eine flexible Nutzung
• Leichtgewichtige Performance, ohne eine komplexe Projektverwaltung

Ein Generic Code Editor ist kein vollständiges Entwicklungswerkzeug, sondern ein flexibler Editor zur Bearbeitung von Code in mehreren Sprachen. Er eignet sich besonders für schnelle Änderungen an Code-Dateien, Skripte oder für Entwickler, die in mehreren Programmiersprachen arbeiten.

Vorteile eines Generic Code Editors

1. Flexibilität – Unterstützt verschiedene Sprachen ohne spezielle Anpassungen.
2. Leichtgewichtigkeit – Schneller Start und geringe Systemanforderungen.
3. Erweiterbarkeit – Plugins und Erweiterungen können individuell hinzugefügt werden.
4. Plattformunabhängig – Funktioniert auf Windows, macOS und Linux.
5. Kein Overhead – Keine komplexen Projektkonfigurationen notwendig.

Bekannte Generic Code Editors

• Visual Studio Code (VS Code) – Sehr populär mit einer großen Erweiterungsbibliothek. (Siehe auch meinen Beitrag „Visual Studio Code – Das leichte Schwergewicht„)
• Atom – Open-Source-Editor von GitHub (War eines meiner Lieblingseditoren, wird allerdings nicht mehr aktiv weiterentwickelt).
• Sublime Text – Leichtgewichtig, schnell und mit guter Plugin-Unterstützung. (Aktuell eines meiner Lieblingseditoren auf macOS)
• Notepad++ – Einfacher, schneller Editor mit grundlegenden Funktionen. (Aktuell eines meiner Lieblingseditoren auf Windows)
• Vim/NeoVim – Terminal-basierter Editor mit hoher Anpassbarkeit. (Aktuell eines meiner Lieblingseditoren auf Linux-Systemen wie KALI, Debian und Ubuntu)

Vergleich: GCE vs. IDE

Was zählt nicht als Generic Code Editor?

Einige Entwicklungsumgebungen unterstützen zwar mehrere Sprachen, sind aber keine GCEs, weil sie mehr als nur reine Code-Bearbeitung bieten. Dazu gehören:

1. IntelliJ IDEA – Die Power-IDE für Java & Co.

IntelliJ IDEA von JetBrains ist primär für Java und Kotlin entwickelt, unterstützt jedoch durch Plugins viele weitere Sprachen. Es bietet:

• Automatisches Refactoring für sauberen Code
• Integrierten Debugger zur Fehleranalyse
• Projektmanagement mit Build-Tools (Maven, Gradle)
• Intelligente Code-Analyse zur Fehlererkennung
• Version Control (Git, SVN) direkt integriert

2. Visual Studio – Microsofts leistungsstarke Entwicklungsumgebung

Visual Studio ist besonders für .NET- und C#-Entwicklung optimiert, unterstützt aber auch C++, Python und andere Sprachen. Seine Merkmale umfassen:

• Integrierte Compiler & Debugging-Tools
• Automatische Code-Generierung & AI-gestützte Features
• GUI-Designer für App-Entwicklung
• Umfassendes Projektmanagement mit Solution Explorer

Was ist mit Visual Studio Code?

Eine interessante Ausnahme ist Visual Studio Code (VS Code). Es ist leichter als Visual Studio, unterstützt viele Sprachen und wird oft als Generic Code Editor genutzt. Durch Erweiterungen kann es jedoch zu einer fast vollständigen IDE ausgebaut werden.

Wann solltest du einen GCE statt einer IDE nutzen?

Ein Generic Code Editor eignet sich besonders, wenn du:

• Mit vielen verschiedenen Programmiersprachen arbeitest und schnelle Bearbeitung benötigst.
• Kein vollständiges Projektmanagement brauchst, sondern nur einzelne Dateien editieren möchtest.
• Leichtgewichtige Tools bevorzugst, die nicht viele Ressourcen verbrauchen.
• Oft in Terminal- oder Cloud-Umgebungen arbeitest und keinen GUI-basierten Editor benötigst.

Fazit: GCE oder IDE?

Ein echter Generic Code Editor ist leichtgewichtig, universell und nicht an eine bestimmte Sprache oder Umgebung gebunden. IntelliJ IDEA und Visual Studio hingegen sind vollständige IDEs mit Debugging- und Projektmanagement-Funktionen, die über die Eigenschaften eines GCE hinausgehen.

Wenn du also nach einem leistungsstarken Entwicklungswerkzeug mit Debugging und Projektmanagement suchst, sind IntelliJ IDEA oder Visual Studio großartige Optionen. Falls du hingegen einen flexiblen, leichtgewichtigen Editor für mehrere Sprachen möchtest, sind VS Code, Sublime Text oder Vim die bessere Wahl.

Der Beitrag Generic Code Editors – Flexibel, Leicht & Vielseitig erschien zuerst auf CEOsBay.

Was ist Infrastructure-as-Code (IaC)?

Infrastructure-as-Code ist ein Ansatz zur Verwaltung und Bereitstellung von IT-Infrastrukturen durch Code anstelle manueller Prozesse. Anstatt Server, Netzwerke und andere Infrastrukturkomponenten manuell einzurichten, werden sie in einer maschinenlesbaren Konfigurationsdatei definiert und automatisiert bereitgestellt. Dies ermöglicht eine konsistente und wiederholbare Bereitstellung von IT-Ressourcen.

Vorteile

1. Automatisierung und Effizienz

Durch die Nutzung von IaC lassen sich IT-Infrastrukturen automatisiert bereitstellen und verwalten. Dies reduziert Fehlerquellen und beschleunigt den Bereitstellungsprozess erheblich.

2. Konsistenz und Reproduzierbarkeit

Damit wird sichergestellt, dass jede Bereitstellung identisch ist. Dadurch werden Inkonsistenzen zwischen Entwicklungs-, Test- und Produktionsumgebungen minimiert.

3. Skalierbarkeit

Da man Infrastruktur per Code definiert, können Unternehmen ihre Systeme einfach hoch- oder herunterskalieren, je nach Bedarf.

4. Nachvollziehbarkeit und Versionierung

IaC erlaubt es, Änderungen an der Infrastruktur wie Code zu behandeln. Dies bedeutet, dass man jede Modifikation nachvollziehen und bei Bedarf rückgängig machen kann.

5. Kosteneinsparungen

Automatisierung und schnellere Bereitstellungen sparen Zeit und damit auch Kosten. Zudem kann man durch optimierte Ressourcenverwaltung eine effizientere Nutzung von Infrastruktur erzielen.

Beliebte IaC-Tools

Es gibt eine Vielzahl von Tools, die in der Praxis zum Einsatz kommen. Hier sind einige der bekanntesten:

• Terraform – Ein Open-Source-Tool von HashiCorp, für die Verwaltung verschiedener Cloud-Plattformen. Mehr Informationen gibt es auf der offiziellen Webseite und auf GitHub. Ich werde in der Zukunft sicherlich auch noch einen gesonderten Beitrag darüber schreiben.
• AWS CloudFormation – Ein von Amazon bereitgestelltes Tool zur Automatisierung der AWS-Infrastruktur.
• Ansible – Ein einfaches und leistungsfähiges Automatisierungstool, welches man auch für das Konfigurationsmanagement nutzen kann.
• Puppet und Chef – Zwei weitere populäre Tools zur Automatisierung und Verwaltung von IT-Infrastrukturen.

Best Practices für IaC

Um das volle Potenzial von IaC auszuschöpfen, sollte man einige bewährte Vorgehensweisen beachten:

• Verwendung von Versionskontrolle: Man sollte IaC wie Software behandeln und in Git oder anderen Versionskontrollsystemen speichern.
• Modularisierung der Infrastruktur: Durch das Zerlegen der Infrastruktur in kleinere Module wird die Wiederverwendbarkeit und Wartbarkeit erhöht.
• Regelmäßiges Testen: Infrastruktur-Code sollte man vor der Bereitstellung testen, um Fehler zu vermeiden. Hierzu macht es Sinn, die Kategorie Testing im Auge zu behalten.
• Dokumentation und Schulung: Eine gute Dokumentation und geschulte Teams erleichtern den Umgang mit IaC.

Fazit

Infrastructure-as-Code ist ein leistungsfähiger Ansatz, der Unternehmen dabei hilft, ihre IT-Infrastruktur effizienter und sicherer zu verwalten. Durch Automatisierung, Konsistenz und Skalierbarkeit bietet IaC erhebliche Vorteile und wird in der modernen IT-Landschaft immer wichtiger. Unternehmen, die sich frühzeitig mit IaC auseinandersetzen und es implementieren, können langfristig von höherer Agilität und niedrigeren Betriebskosten profitieren.

Der Beitrag IaC (Infrastructure-as-Code) erschien zuerst auf CEOsBay.

Grundlagen Inkrementelles Entwicklungsmodell

Das inkrementelle Entwicklungsmodell basiert auf der Idee, ein umfangreiches Softwareprojekt in kleinere, handhabbare Teile zu zerlegen. Entwickler implementieren diese Teile in aufeinanderfolgenden Phasen, wobei jedes Inkrement auf dem vorherigen aufbaut und es erweitert. Diese Vorgehensweise ermöglicht eine frühzeitige Auslieferung von Teilfunktionalitäten, was wiederum eine schnelle Rückmeldung von den Endnutzern erlaubt. Die konsequente Einbindung von Nutzerfeedback in den Entwicklungsprozess führt zu einer höheren Benutzerzufriedenheit und ermöglicht eine effektivere Fehlerbehebung.

Ursprung und Entwicklung

Die Ursprünge des inkrementellen Entwicklungsmodells liegen in den 1960er und 1970er Jahren. Als Softwareingenieure nach flexibleren Alternativen zu den bis dahin vorherrschenden, starren Entwicklungsmodellen suchten. Das inkrementelle Modell bildete eine Antwort auf die wachsenden Anforderungen an Softwarelösungen. Besonders, die Notwendigkeit, sich schnell an veränderte Benutzeranforderungen und Marktbedingungen anzupassen.

Optimale Anwendungsmethoden

Für eine erfolgreiche Anwendung des inkrementellen Entwicklungsmodells gilt es, einige Schlüsselelemente zu berücksichtigen:

1. Klare Definition der Inkremente: Teams sollten jedes Inkrement klar definieren und festlegen, welche Funktionen es umfasst.
2. Kontinuierliche Integration und Testing: Die kontinuierliche Integration neuer Inkremente und deren umfassendes Testing sind unerlässlich. Dadurch lassen sich Fehler frühzeitig identifizieren und somit die Softwarequalität sichern. (Siehe meinen Beitrag über CI/CD – Continuous Integration und Continuous Deployment.)
3. Nutzerfeedback einbeziehen: Entwicklerteams müssen Nutzerfeedback aktiv einfordern und in den Entwicklungsprozess integrieren, um die Software stetig zu verbessern.

Inkrementelles Entwicklungsmodell Beispiele aus der Praxis

1. Mobile Applikationen: Bei der Entwicklung mobiler Apps hat sich das inkrementelle Modell als besonders effektiv erwiesen. Entwicklerteams können einzelne Funktionen wie Benutzeranmeldung, Profilerstellung und Nachrichtenfunktion in separaten Inkrementen implementieren und ausliefern.
2. Web-Plattformen: Auch im Bereich der Web-Entwicklung findet das inkrementelle Modell breite Anwendung. Beispielsweise kann ein E-Commerce-Unternehmen seinen Online-Shop schrittweise um Funktionen wie Produktsuche, Warenkorb und Zahlungsabwicklung erweitern.

Fazit

Ein inkrementelles Entwicklungsmodell stellt einen flexiblen und effizienten Ansatz in der Softwareentwicklung dar. Durch die Zerlegung des Gesamtprojekts in kleinere Teile, die man schrittweise implementiert und testet, ermöglicht eine schnelle Reaktion auf Benutzerfeedback und sich verändernde Anforderungen. Zahlreiche Erfolgsbeispiele aus der Praxis belegen die Effektivität dieses Modells. Dies macht es zu einer attraktiven Wahl für Softwareentwicklungsprojekte unterschiedlichster Art.

Der Beitrag Inkrementelles Entwicklungsmodell – Kleine Schritte, große Fortschritte erschien zuerst auf CEOsBay.

Git wurde ursprünglich von Linus Torvalds im Jahr 2005 für die Entwicklung des Linux-Kernels entwickelt, wobei andere Kernel-Entwickler zur anfänglichen Entwicklung wesentliche Beiträge geleistet haben. Seit 2005 ist Junio Hamano der Hauptverantwortliche. Wie bei den meisten anderen verteilten Versionskontrollsystemen und im Gegensatz zu den meisten Client-Server-Systemen ist jedes Git-Verzeichnis auf jedem Computer ein vollwertiges Repository mit einer vollständigen Historie und vollständigen Versionsverfolgungsfunktionen, unabhängig vom Netzwerkzugang oder einem zentralen Server. Git ist, wie Anfangs angesprochen, freie und Open Source Software, die unter der GPL-2.0-Lizenz vertrieben wird.

Eine kurze Anekdote über Git und dessen Abbreviatur

Linus Torvalds witzelte sarkastisch über den Namen git (was im britischen Slang „unangenehme Person“ bedeutet): „Ich bin ein egoistischer Mistkerl und benenne alle meine Projekte nach mir selbst. Erst „Linux“, jetzt „Git“. Die Manpage beschreibt Git als „the stupid content tracker“ Die Read-me-Datei des Quellcodes führt weiter aus:
„Git“ kann alles Mögliche bedeuten, je nach Laune (Ich werde dies in der englischen Sprache belassen, da es so wahrscheinlich mehr Sinn macht 😉 ).

• Random three-letter combination that is pronounceable, and not actually used by any common UNIX command. The fact that it is a mispronunciation of „get“ may or may not be relevant.
• Stupid. Contemptible and despicable. Simple. Take your pick from the dictionary of slang.
• „Global information tracker“: you’re in a good mood, and it actually works for you. Angels sing, and a light suddenly fills the room.
• „Goddamn idiotic truckload of sh*t“: when it breaks.

Um Git zu verstehen sind im Prinzip 8 Begriffe relevant. Repository (Kurz: Repo), die Versionskontrolle, Fork bzw. Forking (Gabel bzw. Gabelung), Branch (Verzweigung), Stage (Phase oder Stadium), Modified (modifiziert), Commit (Verbindlichkeit) und Merge (Zusammenführung). Diese Begriffe werde ich nachfolgend beschreiben.

Was ist eine Repository?

Eine Repository, kurz Repo genannt, ist ein Speicherort für Softwarepakete. Oft wird auch ein Inhaltsverzeichnis zusammen mit Metadaten (Metainformationen bzw. -daten sind strukturierte Daten, die Informationen über Merkmale anderer Daten enthalten) gespeichert. Eine Software-Repository wird in der Regel von Source-Control-Managern (SCM) oder Repository-Managern (Ein Repository-Manager ist eine dedizierte Server-Anwendung, die für die Verwaltung von Repositories mit binären Komponenten entwickelt wurde) verwaltet – Dazu teilweise mehr in der Versionskontrolle und in späteren Beiträgen. Paketmanager ermöglichen die automatische Installation und Aktualisierung von Repositories (Deshalb auch „Pakete“ genannt).

Viele Organisationen und Softwarehersteller unterhalten zu diesem Zweck Server im Internet, teilweise kostenlos oder gegen eine Gebühr. Repositories können können verschiedene Programmiersprachen, Betriebssysteme, Spiele oder andere Anwendungen sowie Dokumente und Daten beherbergen. Die Betreiber solcher Repositories stellen in der Regel ein Paketverwaltungssystem zur Verfügung. Folglich Werkzeuge, mit denen Softwarepakete aus den Repositories gesucht, installiert und anderweitig bearbeitet werden können. Viele Linux-Distributionen (Der Begriff Distribution stammt aus dem Lateinischen „distributio“ und hat im Zusammenhang mit Software zwei unterschiedliche Bedeutungen: Softwarepaketierung und Softwareverteilung) verwenden z. B. das Advanced Packaging Tool (APT), das häufig in Debian-basierten Distributionen zu finden ist oder yum in Red Hat-basierten Distributionen. Es gibt auch mehrere unabhängige Paketverwaltungssysteme, wie z. B. pacman, dass in Arch Linux verwendet wird und equo, welches in Sabayon Linux zu finden ist. Ich bin primär mit Debian-basierten Distributionen unterwegs. Werde ich aber in zukünftigen Beiträgen ausführlicher thematisieren.

Was ist Versionskontrolle?

Die Versionskontrolle unterstützt Entwickler bei der Verfolgung und Verwaltung von Änderungen am Quellcode eines Softwareprojekts. Wenn ein Projekt und die Anzahl der Programmierer wachsen, wird die Versionskontrolle unabdingbar. Doch in der Regel kommen sowohl bei kleineren als auch größeren Softwareprojekten mehrere Personen zum Einsatz, die gemeinsam an dem Quellcode arbeiten. Wenn man beispielsweise als Core-Entwickler an einem bestimmten Teil der Codebasis arbeiten möchte, ist es nicht förderlich oder effizient, wenn der Quellcode direkt bearbeitet wird, da zeitgleich noch andere die an dem Projekt beteiligt sind und daran arbeiten. Dies kann am Ende des Tages für ein enormes Durcheinander sorgen 😀

Da man auf dieses Durcheinander gut verzichten kann, arbeitet man als Entwickler mit einer Versionskontrolle „sicher“ durch branching (Verzweigungen) und merging (Zusammenführungen). „Sicher“ in Anführungszeichen, da es auch da einige Stolpersteine gibt 😉

Beim branching dupliziert ein Entwickler den Teil des Quellcodes (Das so genannte Repository bzw. die Repo), der für ihn relevant ist und kann die Änderungen genau an diesem Teil des Codes vornehmen, ohne den Rest des Projekts zu beeinträchtigen. Sobald der Entwickler seinen Teil des Codes ordnungsgemäß fertiggestellt hat, kann er diesen Code wieder in den Hauptquellcode mergen (einbinden), um es offiziell zu machen. All diese Änderungen werden protokolliert, kommentiert und können bei Bedarf eingesehen, kontrolliert oder rückgängig gemacht werden.

Was ist Fork. bzw. Forking?

Ein Fork ist eine Kopie einer Repository. Das Forken einer Repository ermöglicht es, frei mit Änderungen zu experimentieren, ohne das Originalprojekt zu beeinträchtigen. Dieser Begriff wird auch anderweitig genutzt, doch darauf werde ich jetzt nicht weiter eingehen 😀

Was ist Branch bzw. Branching?

Ein Branch (Zweig) ist ein hervorstehender Teil eines Baumes. Etwas, dass aus einem Hauptteil herausragt. So, auch in unserem Kontext. Ein Zweig stellt eine unabhängige Entwicklungslinie dar. Zweige dienen als Abstraktion für den Prozess der Bearbeitung (Stage/Commit). Man kann sie sich als eine Möglichkeit vorstellen, ein neues Arbeitsverzeichnis, einen Bereitstellungsbereich und/oder einen Projektverlauf anzufordern.

Was ist Modified bzw. Modifying?

Modified (Geändert) bedeutet, dass die Datei(en) geändert wurden aber noch nicht in die Datenbank bzw. Repository übertragen wurden.

Was ist Stage bzw. Staging?

Staged (Phase/Stadium) bedeutet, dass eine geänderte Datei in ihrer aktuellen Version markiert wurde, um sie in dem nächsten Commit-Snapshot (Schnappschuss) zu übernehmen.

Was ist Commit bzw. Committing ?

Commits (Verbindlichkeiten) sind die zentralen Bausteineinheiten einer Git-Projektzeitleiste. Sie können als Schnappschüsse oder Meilensteine entlang der Zeitachse eines Git-Projekts betrachtet werden. Commits werden mit dem Befehl „git commit“ erstellt, um den Zustand eines Projekts zu diesem Zeitpunkt festzuhalten. Im Endeffekt wie das Zwischenspeichern mit F5 bei Spielen oder Strg + S bei der regulären Arbeit am Computer. In der Betrachtungsweise einiger interessanter und manchmal nervtötender Zeitgenossen – Lediglich etwas fundamentaler 😉

Merge

Mit dem Merging-Befehl fügt Git einen geforkten (aufgegabelten) Verlauf wieder zusammen. Mit dem Befehl „git merge“ kann man die unabhängigen Entwicklungslinien, die mit dem Befehl „git branch“ erstellt wurden, in einen einzigen Zweig integrieren.

Fazit

Alles in allem sollte dies für eine kurze Erklärung reichen. In naher Zukunft werde ich auch ein Tutorial über die Nutzung von Git schreiben. Sicherlich gibt es heutzutage auch kommerzielle Cloud-Lösungen wie GitHub oder GitKraken, die diese Schritte auf wenige Mausklicks reduzieren und so eine nahtlosere Zusammenarbeit ohne etwaige Vorkenntnisse ermöglichen, doch dies werde ich auch in zukünftigen Beiträgen thematisieren.

Der Beitrag Git – Die Codeverwaltung für effiziente Zusammenarbeit revolutionieren erschien zuerst auf CEOsBay.