# Git + Codeberg

Jan Grosser 
 
2025-12-04, <a href="https://trolug.de">TroLUG</a> 
 
CC-BY 4.0 (sofern nicht anders angegeben)

---

## Was wir heute machen werden (1)

### Git 
* Git Einstellungen
* Neues Repo anlegen; Kopie erstellen
* Typischer lokaler Workflow 
* Die Datei `.gitignore`
* Änderungen verwerfen
* Zurück in die Vergangenheit
* Was Branches sind; Workflow mit Branches

-v-

## Was wir heute machen werden (2)

### Codeberg 
* Einstellungen CB-Account 
* Neues Repo auf CB erstellen
* Test-Repo nach CB pushen

-v-

## Themen für nächsten Workshop?

* Git-Tools und Helper
* Fork erstellen
* Pull Request erstellen
* Pull Request bearbeiten (testen, mergen, rejecten)
* ...

---

## Meine Vorerfahrungen

* Nutze das seit ~ 10y für eigene, private Projekte 
* Flache Lernkurve, definitiv kein Git-Guru
* Nutze Codeberg nun intensiver durch [TroLUG](https://codeberg.org/TroLUG)
* Benutze das beruflich (leider) kaum

---

## Was ist Git?

* Freie Software: GNU GPL v2
* Von Linus Torvalds zur Versionskontrolle des Linux Kernels entwickelt
* Zuerst erschienen 2005
* Mächtige Versionskontrolle, vorzugsweise für textuelle Informationen (Quellcode, Markdown)
* Erlaubt die gemeinsame, verteilte Arbeit an Dateien
* Ist für alle gängigen Betriebssysteme verfügbar
* In vielen IDEs integriert

---

## Was ist Codeberg?

* Codeberg e.V. ist ein [gemeinnütziger Verein aus Berlin](https://docs.codeberg.org/getting-started/what-is-codeberg/#what-is-codeberg-e.v.%3F)
* Stellt eine SW-Entwicklungsplattform (und andere Tools) ähnlich Github o.ä. zur Verfügung: https://codeberg.org
* Die Software nutzt die freie SW [Forgejo](https://forgejo.org/)
* Zum aktiven Mitmachen (Contributions, eigene Repos) benötigt man einen kostenlosen Account
* Ergänzt die Funktionen von Git => SW Projekt-Management

---

---

## Mitmachen?

Link zur <a href="https:sshx.io">sshx</a> Session → Chat

(Temporärer Linux-Container)

---

## Git Einstellungen

```bash
> git --version 
git version 2.43.0
> git config --list
[...]

> git config --global user.name "John Doe"
> git config --global user.email "john@example.net"
> git config --global init.defaultBranch "main"
```

---

## Neues Repo(sitory) anlegen

Ein Repo ist ein "Container" von zusammengehörenden Dateien

```bash
> mkdir -p ~/src/firstgit
> cd $_
> git init
Initialized empty Git repository in /home/john/src/firstgit/.git/

> ls -a
. .. .git
```

-v-

## (Lokale) Kopie eines Repos erstellen

Das nennt man klonen (clone)

```bash
# Lokales Repo
> cd ~/src
> git clone firstgit/ firstgit-copy
Cloning into 'firstgit-copy'...
warning: You appear to have cloned an empty repository.
done.

> ls first*
firstgit:

firstgit-copy:

# Entferntes Repo (hier: Codeberg)
> git clone https://codeberg.org/TroLUG/sandbox.git
Cloning into 'sandbox'...
remote: Enumerating objects: 9, done.
remote: Counting objects: 100% (3/3), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 9 (delta 0), reused 0 (delta 0), pack-reused 6 (from 1)
Receiving objects: 100% (9/9), done.
Resolving deltas: 100% (1/1), done.
```

---

## Ein paar weitere Begriffe

* Arbeitsverzeichnis - Das ist das Verzeichnis mit den Dateien des Repos, also bspw. `firstgit/`
* Index/Stage - Eine Art "Zwischenstufe", wie ein Warenkorb für zusammengehörige geänderte Dateien
* Commit - Ein "Schnappschuss" der Dateien in einem Repo
* HEAD - Eine Art Zeiger auf den aktuellen Commit

---

## Typischer lokaler Workflow (1)

```bash
# Ins Arbeitsverzeichnis wechseln
> cd ~/src/firstgit
# Eine Datei anlegen 
> echo "Test" >> test.txt

# Status ansehen
# mit alias gs="git status" kann man sich das Leben etwas einfacher machen ;)
> git status
On branch main

No commits yet

Untracked files:
 (use "git add <file>..." to include in what will be committed)
 test.txt

nothing added to commit but untracked files present (use "git add" to track)
```

-v-

## Typischer lokaler Workflow (2)

```bash
# Geänderte Datei in die Stage nehmen 
> git add test.txt 
> git status
On branch main

No commits yet

Changes to be committed:
 (use "git rm --cached <file>..." to unstage)
 new file: test.txt

```

-v-

## Typischer lokaler Workflow (3)

```bash
# Ersten Commit machen 
> git commit -m "Erste Version der Datei angelegt"
[main (root-commit) aadc1ad] Erste Version der Datei angelegt
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt

> git status
On branch main
nothing to commit, working tree clean

> git log 
commit aadc1ad6e24a8fe8a855b7267594bde51909e72d (HEAD -> main)
Author: John Doe <john@example.com>
Date: Wed Oct 15 19:26:25 2025 +0200

Erste Version der Datei angelegt
```

-v-

## Typischer lokaler Workflow (4)

```bash
> echo "Weitere Zeie" >> test.txt 
> cat test.txt 
Test
Weitere Zeile

> git status
On branch main
Changes not staged for commit:
 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
 modified: test.txt

no changes added to commit (use "git add" and/or "git commit -a")
```

-v-

## Typischer lokaler Workflow (5)

```bash
> git diff 
diff --git a/test.txt b/test.txt
index 345e6ae..9a7bce1 100644
--- a/test.txt
+++ b/test.txt
@@ -1 +1,2 @@
 Test
+Weitere Zeile

> echo "Es geht noch mehr!" >> test2.txt

> git status 
On branch main
Changes not staged for commit:
 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
 modified: test.txt

Untracked files:
 (use "git add <file>..." to include in what will be committed)
 test2.txt

no changes added to commit (use "git add" and/or "git commit -a")
```

-v-

## Typischer lokaler Workflow (6)

```bash
> git add *
> git commit -m "Zusätzliche Zeile und zweite Datei"
[main e6b1cf9] Zusätzliche Zeile und zweite Datei
 2 files changed, 2 insertions(+)
 create mode 100644 test2.txt

> git log 
commit e6b1cf9a423a962a20fc592f2aa75863d35f1a23 (HEAD -> main)
Author: John Doe <john@example.net>
Date: Wed Oct 15 19:48:51 2025 +0200

Zusätzliche Zeile und zweite Datei

commit aadc1ad6e24a8fe8a855b7267594bde51909e72d
Author: John Doe <john@example.net>
Date: Wed Oct 15 19:26:25 2025 +0200

Erste Version der Datei angelegt
```

---

## Die Datei .gitignore

* Über `.gitignore` kann man Dateien und ganze Unterordner im Arbeitsverzeichnis von Git ausnehmen:
  * Compilate
  * Credentials
  * ...

```
> cat .gitignore
tmp
credentials.conf
# Vim swap files
**/*.swp
# GCC compiler output
**/*.o 
**/*.a 
**/*.exe
```

---

## Ein paar Tipps

* "Atomare" Commits machen, d.h. in einen Commit nur sinn-zusammenhänge Änderungen bündeln. Später kann man einzelne Commits rückgängig machen (`revert`)
* Aussagekräftige Commit-Messages nutzen. Nicht beschreiben, was geändert wurde sondern besser warum

---

## Änderungen verwerfen (1)

Situation: Wir haben Bullshit gemacht und das schon im Stage, aber noch nicht committet

```bash
# Bullshit machen
> echo "Bullshit" >> test.txt
> git add test.txt

# Aus dem Stage entfernen bzw. Stage auf HEAD zurücksetzen
> git restore --staged test.txt
> git status
On branch main
Changes not staged for commit:
 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
 modified: test.txt

no changes added to commit (use "git add" and/or "git commit -a")

# Änderungen zurücksetzen; setze test.txt auch im Arbeitsverzeichnis
# auf HEAD (Status letzter Commit)
> git restore --worktree test.txt
Updated 1 path from the index

# Alles wieder in Ordnung :)
> git status 
On branch main
nothing to commit, working tree clean
```

-v-

## Änderungen verwerfen (2)

Situation: Wir haben komplexen Bullshit gemacht, und wollen alles verwerfen (zurück zu HEAD)

```bash
# Bullshit machen 
> echo "Bullshit" >> test.txt
> git rm test2.txt
rm 'test2.txt'

# Viel Schaden im Arbeitsverzeichnis, aber nicht im Stage
> git status
On branch main
Changes to be committed:
 (use "git restore --staged <file>..." to unstage)
 deleted: test2.txt

Changes not staged for commit:
 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
 modified: test.txt

# Arbeitsverzeichnis auf den HEAD (letzten Commit) zurücksetzen
> git reset --hard HEAD
HEAD is now at e6b1cf9 Zusätzliche Zeile und zweite Datei

# Alles wieder in ordnung :)
> git status
On branch main
nothing to commit, working tree clean
```

---

## Zurück in die Vergangenheit (1)

Situation: Wir haben eine Bullshit-Änderung bereits committet

```bash
# Bullshit committen
> echo "Bullshit" >> test.txt
> git rm test2.txt
rm 'test2.txt'
> git add test.txt
> git commit -m "Was für ein Bullshit!"
[main 30ceee9] Was für ein Bullshit!
 2 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 test2.txt

# In test.txt steht nun Bullshit und test2.txt ist weg :(
> ls -a 
. .. .git test.txt
```

-v-

## Zurück in die Vergangenheit (2)

**Situation:** Wir haben eine Bullshit-Änderung bereits committet

```bash
# Wir wollen den Commit 30ceee9 nicht mehr
> git log --oneline
30ceee9 (HEAD -> main) Was für ein Bullshit!
e6b1cf9 Zusätzliche Zeile und zweite Datei
aadc1ad Erste Version der Datei angelegt

# Einzelnen Commit rückgängig machen
> git revert 30ceee9 
[Es öffnet sich ein Fenster für die Commit-Message]

# Der neue Commit 527fcf1 macht 30ceee9 rückgängig 
# Der revert ist in der Historie transparent
> git log --oneline
527fcf1 (HEAD -> main) Revert "Was für ein Bullshit!"
30ceee9 Was für ein Bullshit!
e6b1cf9 Zusätzliche Zeile und zweite Datei
aadc1ad Erste Version der Datei angelegt

# Alles wieder da! :)
> ls -a 
.  ..  .git  test2.txt  test.txt
```

---

## Übersicht Git Kommandos

CC-BY-NC-SA 4.0 [Enrique Crespo](https://aprendiendoarduino.wordpress.com/category/git/)

---

## Was sind Branches? (1)

* In jedem Repo gibt es mindestens einen Branch; i.d.R den Hauptbranch `main`
* An jedem Commit kann einen neuer Branch erstellt werden. Er ist wie eine Kopie des Codes und wird separat von `main` weiterentwickelt (mit eigener Commit-Historie)
* Später kann der Branch mit `main` gemerged werden
* Eignen sich, um spezielle Features/Funktionen zunächst getrennt weiterzuentwickeln
* Der Branch `main` kann so "sauber" bleiben von nicht-funktionalem "Code in Development"

-v-

## Was sind Branches? (2)

---

## Workflow mit Branches (1)

Branch `dev` erstellen und dort Änderungen machen

``` bash
# Aktuelle Branches anzeigen 
> git branch 
* main

# Neuen Branch dev anlegen und dorthin wechseln
> git switch -c dev 
Switched to a new branch 'dev'
# Datei dev.txt in Branch dev anlegen 
> touch dev.txt
> git add dev.txt
> git commit -m "Datei dev.txt hinzugefügt"
[dev 75c8fc8] Datei dev.txt hinzugefügt
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 dev.txt

# Branches ansehen 
# -- dev --
> ls -a 
.  ..  dev.txt  .git  test2.txt  test.txt
# -- main --
> git switch main 
Switched to branch 'main'
> ls -a 
.  ..  .git  test2.txt  test.txt
```

-v-

## Workflow mit Branches (2)

Änderungen aus `dev` in den Branch `main` übernehmen

```bash
# Wir sind in Branch main:
> git status
On branch main
nothing to commit, working tree clean
# Was haben wir an Dateien im Arbeitsverzeichnis?
> ls -a 
.  ..  .git  test2.txt  test.txt
# Die Option --all zeigt die Commits aller Branches an, nicht nur des aktuellen
> git log --oneline --all
75c8fc8 (dev) Datei dev.txt hinzugefügt
527fcf1 (HEAD -> main) Revert "Was für ein Bullshit!"
30ceee9 Was für ein Bullshit!
e6b1cf9 Zusätzliche Zeile und zweite Datei
aadc1ad Erste Version der Datei angelegt
# Nun mergen wir dev --> main 
> git merge dev 
Updating 527fcf1..75c8fc8
Fast-forward
 dev.txt | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 dev.txt
# Erinnerung: Wir sind in main !
> ls -a 
.  ..  dev.txt  .git  test2.txt  test.txt
```

---

## Ein paar Tipps

* Keine Angst vor Branches und Mergen - einfach mal lokal damit spielen
* Keinen ungetesteten Code in `main` mergen/pushen
* git - Der einfache Einstieg: https://rogerdudler.github.io/git-guide/index.de.html
* Git Cheat Sheet: https://git-scm.com/cheat-sheet
* Vergangene TroLUG-Treffen zu git:
  * 2014-04 Johannes Hubertz - git [(Folien)](https://downloads.trolug.de/2014-04-03_trolug_johannes_hubertz_git.pdf)
  * 2016-05 Tobias Fröhlich - git Workshop [(Folien)](https://downloads.trolug.de/2016-05-12_trolug_tobias_froehlich_git_workshop.html)

---

---

## Einstellungen Codeberg-Account (1)

Globale Email Benachrichtigungs-Einstellungen https://codeberg.org/user/settings/account:

-v-

## Einstellungen Codeberg-Account (2)

SSH und GPG-Keys hinterlegen https://codeberg.org/user/settings/keys:
* Passwortloser Zugriff auf Repos
* Signieren von Commits

---

## Neues Repo auf CB anlegen

In der Web-Oberfläche oben-rechts auf das **+** klicken und "New Repository" auswählen

---

## Test-Repo firstgit nach CB pushen (1)

```bash
# In das Verzeichnis des Repos wechseln
> cd ~/src/firstgit 
# Einfach die Befehle von der Webseite ausführen
> git remote add origin ssh://git@codeberg.org/johndoe/firstgit.git
> git push -u origin main
Enumerating objects: 14, done.
Counting objects: 100% (14/14), done.
Delta compression using up to 16 threads
Compressing objects: 100% (7/7), done.
Writing objects: 100% (14/14), 1.24 KiB | 1.24 MiB/s, done.
Total 14 (delta 0), reused 0 (delta 0), pack-reused 0
To ssh://codeberg.org/johndoe/firstgit.git
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.
```

-v-

## Test-Repo firstgit nach CB pushen (2)

---

## Andere lokale Branches nach CB pushen (1)

```bash
> git push -u origin dev
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
remote:
remote: Create a new pull request for 'dev':
remote:   https://codeberg.org/johndoe/firstgit/compare/main...dev
remote:
To ssh://codeberg.org/johndoe/firstgit.git
 * [new branch]      dev -> dev
branch 'dev' set up to track 'origin/dev'.
```

-v-

## Andere lokale Branches nach CB pushen (2)

---

# Geschafft - Danke!

---

## Terminal-Recording mit asciinema