DIY Individual Prototyping and Systems Engineering

Ähnliche Dokumente
Verlässliche Echtzeitsysteme

Verlässliche Echtzeitsysteme

Verlässliche Echtzeitsysteme

Überblick. Verlässliche Echtzeitsysteme. Annahmen. Die Programmiersprache C. Auch heute noch viel sicherheitskritische Software in C

Überblick. Verlässliche Echtzeitsysteme. Zwei Prinzipien für die Übung. Verzeichnisstruktur in der Übung. Übungen zur Vorlesung

Von SVN zu Git. Daniel Willmann cbna

Arbeiten mit dem Versionsverwaltungssystem. Jannik Kramer Proseminar Werkzeuge für das wissenschaftliche Arbeiten

Überblick. Middleware Cloud Computing Übung. Übungsaufgaben. Termine und Ansprechpartner. Organisatorisches

Middleware Cloud Computing Übung

Einführung in Verteilte Versionskontrollsysteme. am Beispiel von Git

Moodle aktuell halten mit Git

Git - Fast Version Control System

git Alexander Bernauer Rico Schiekel

Software Engineering

Versionierung und Bugtracking mit Git(Hub)

Versionsverwaltung für die KU Betriebssysteme. Eine Einführung

Vorlesung Unix-Praktikum

Versionsverwaltung mit git

Enes Kurnaz, Oliver Nagel Institut für Mathematik und Informatik. Versionsverwaltung mit Git

Eine Einführung in das verteilte Quelltextverwaltungssystem Git

Einführung in Git. master. Initial commit

Versionsverwaltung. Seminar Softwareentwicklung in der Wissenschaft Robert Wiesner

Git II. Dezentrale Versionsverwaltung im Team

Git eine kurze Einführung

Source Code Verwaltung mit Git

Git eine kurze Einführung. Malte Schmitz ~ Mai 2012

Git-Grundlagen für Entwickler. Thomas Claudius

Gitting started. Christian Neukirchen. 14dec2011

Git - Grundlagen und Anwendungen

Semesterprojekt Entwicklung einer Suchmaschine für Alternativmethoden zu Tierversuchen. Versionierung und Bugtracking mit GitHub

Linux Cafe Referent: Bernd Strößenreuther

Prof. Dr. Marko Boger. Prof. Dr. Christian Johner. Versionsmanagement

git Änderungen verwalten mit git

Verteilte Versionskontrolle mit GIT Dortmund Ansgar Brauner - GreenPocket GmbH - Köln

Verteile Revisionskontrolle mit GIT

Praktikum Ingenieurinformatik (PI)

Einstieg in Git. Lukáš Kubánek

git Workshop Matthias Beyer Hochschule Furtwangen University matthias. hs-furtwangen. de beyermatthias. de 19.

Git. Dezentrale Versionsverwaltung im Team - Grundlagen und Workflows. von René Preißel, Bjørn Stachmann. 2., aktualisierte und erweiterte Auflage

Programmieren 1 11 Versionsverwaltung mit Git - Grundlagen -

Versionsverwaltung mit GIT

Versionierung für OpenSourcler

Konfigurationsdateien mit Git verwalten

Revisionskontrollsystem GIT

Versionkontrolle mit git

Spiel, Spaß und Spannung mit Git

Apache Subversion (SVN)

Git in großen Projekten

Einführung in Git. Dirk Deimeke. 19. August My own IT. ddeimeke (My own IT) Einführung in Git 19. August / 23

Dezentrale Versionsverwaltung

Dr. R. Guderlei exxcellent solutions gmbh Tim Felgentreff HPI. Versionsmanagement. Zentral oder Verteilt?

Überblick. Verteilte Systeme Übung. Übungsaufgaben. Termine und Ansprechpartner. Organisatorisches

Tutorium SS17 EINFÜHRUNG + BREAKOUT

Einführung zu Git. Das Nötigste für die Studienarbeit im Modul Datenkommunikation. Ege Inanc

Nicht alltägliche Git Funktionen

Einführung in git. Johannes Gilger & Matthias Lederhofer. Rechen- und Kommunikationszentrum der RWTH Aachen Network Operation Center. 14.

Versionskontrolle mit Git

Medieninformatik Praktikum. Jens Rademacher

Programmieren 2 06 Git-Teamwork und Egit

Git-Workflows im Alltag

git & git-flow Jens Sandmann Warpzone Münster e.v. Jens Sandmann (WZ) git & git-flow / 31

Mapra: C++ Teil 3. Felix Gruber, Michael Rom. IGPM, RWTH Aachen. 10. Mai 2016

Vorlesung Programmieren. Versionskontrollsysteme. Ziele von VCS. Versionskontrolle

Julius Plenz. Valentin Haenel. Git. Verteilte Versionsverwaltung für Code Dokumente. 2. Auflage. Open Source Press

Einführung Git Interna Workflows Referenzen. Git. Fast Version Control System. Michael Kuhn

Semesterprojekt Implementierung eines Brettspiels (inklusive computergesteuerter Spieler) Versionierung und Bugtracking mit GitHub

Git-Workshop, Teil I

DNUG FN TOBIAS ALLWEIER

Versionsverwaltung mit SVN

git verteilte Versionskontrolle

Versionsverwaltung. Dr.-Ing. Matthias Sand. Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2009

WOZU VERSIONSKONTROLLE?

Versionsverwaltung mit git: Warum und wie.

Apache Subversion (SVN)

Versionsverwaltung mit Git. Eine Einführung ins Source Code Management

Versionskontrolle. Vortrag im Master-Praktikum MindStreams Sommersemester Michael Fiedler 30.

Mapra: C++ Teil 5. Felix Gruber, Sven Groß. 16. Mai IGPM, RWTH Aachen. Felix Gruber, Sven Groß (IGPM) Mapra: C++ Teil 5 16.

Versionsmanagement. Software(technik)praktikum: Vorlesung 3: Versionsmanagement

Git-Zusammenfassung. Autor: Michael Merz 1. Version vom

Crashkurs Subversion / Trac / Provisioning. Jan Zieschang, , Berlin

Versionsverwaltung von Softwareartefakten. 21. Oktober 2014

Semesterprojekt Semantic Text Browsing

Torsten Flatter inovex GmbH. "Git.NET" gibt's nicht?

Arbeiten mit Git. Member of the Helmholtz-Association. 28. April 2015 Ingo Heimbach PGI/JCNS

2 Erste Schritte mit der Kommandozeile

eclipse - EGit HowTo

Praktische Einführung in die Versionsverwaltung mit Eclipse

Programmieren 2 05 Versionsverwaltung mit Git

Igitt?! Git für Anfängerinnen und Anfänger Linux höchstpersönlich.

GIT. Florian Westphal. 29. November D/F260502D 1C81 1AD5 EA8F E8EE 5E2F DA6C F D

Software Engineering in der Praxis

Die Projek*ools. Files, Git, Tickets & Time

Mitmachen bei Git(Hub)-Projekten!

Git. Dezentrale Versionsverwaltung im Team Grundlagen und Workflows. Rene Preißel Björn Stachmann. 2., aktualisierte und erweiterte Auflage

Lehrstuhl für Datenverarbeitung. Technische Universität München. Grundkurs C++ Buildsysteme

Installation von Git für unsere OpenDCC/Fichtelbahn Entwickler Stephan Bauer, Christoph Schörner, Andreas Kuhtz

Versionsverwaltung mit Git

Versionskontrolle mit Subversion

16 Mit Feature-Branches entwickeln

Grundkurs C++ Buildsysteme Versionsverwaltung mit git

Transkript:

DIY Individual Prototyping and Systems Engineering Überblick Übung: Git & Gitlab Peter Wägemann Lehrstuhl für Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität Erlangen-Nürnberg https://www4.cs.fau.de 16. April 2018 1/44 2/44 Anforderungen Git Typische Aufgaben eines Versionsverwaltungssystems sind: Sichern alter Zustände Zusammenführung paralleler Entwicklung Transportmedium Idealerweise zusätzlich: Unabhängige Entwicklung ohne zentrale Infrastruktur Wir werden in DIY git verwenden 2005 von Linus Torvalds für den Linux-Kernel geschrieben Konsequenz der Erfahrungen mit bitkeeper Eigenschaften: dezentrale, parallele Entwicklung Koordinierung hunderter Entwickler Visualisierung von Entwicklungszweigen 3/44 4/44

git-commits git-arbeitsschritte Was speichert ein Commit? Wer? Autor Warum? Commit-Nachricht Was? Vorher/Nachher Zustände Arbeitskopie Vorgänger Commits, auch mehrere! Keine Nachfolger Commit-Id: SHA-1 Hash über Inhalt Gerichteter Azyklischer Graph (engl.: Directed Acyclic Graph: DAG) Sprünge zurück möglich Sprünge vorwärts nicht möglich 0 1 1 2 2 3 3 initiales Repository herunterladen: % git clone <URL> oder anlegen: % git init Commit im Index zusammenbauen ( Verladerampe ): % git add <Datei1> % git add <Datei2> %... anschauen was bei git commit passieren würde: % git status oder Woher kriegt man obere Commits? Symbolische Namen (Zeiger) HEAD: Aktueller Commit Branch: Zeiger auf Commit 5/44 % git diff --cached anschließend Index an das Repository übergeben: % git commit ( Einladen in den LKW ) 6/44 git-arbeitsschritte lokal git-arbeitsschritte entfernt I workspace index local repo commit -a workspace index local repo remote repo add push commit fetch checkout HEAD merge checkout rebase diff HEAD pull diff diff cached 7/44 8/44

git push [<remote> [<branch>]] git pull [<remote> [<branch>]] schiebt Commits nach <remote> in den ausgewählten <branch> dies geht nur, wenn lokales Repo auf dem aktuellen Stand ist! sonst beschwert sich git: % git push origin master holt Änderungen aus remote in den aktuellen Branch verschmilzt aktuellen Branch mit geholten Änderungen gleicher Effekt wie % git fetch && git merge FETCH_HEAD i 2 3 4 5 6 7 2 3 4 5 m To /tmp/test.git! [rejected] master -> master (non-fast-forward) error: failed to push some refs to /tmp/test.git To prevent you from losing history, non-fast-forward updates were rejected Merge the remote changes (e.g. git pull ) before pushing again. See the Note about fast-forwards section of git push --help for details. % git pull origin remote: Counting objects: 5, done. remote: Total 3 (delta 0), reused 0 (delta 0) Unpacking objects: 100% (3/3), done. From /tmp/test 38b95cb..8ec6e93 master -> origin/master Auto-merging test.txt CONFLICT (content): Merge conflict in test.txt Automatic merge failed; fix conflicts and then commit the result. wir müssen das Repository erst auf den aktuellen Stand bringen Änderungen an gleicher Stelle in der Zwischenzeit Konflikte müssen von Hand behoben werden 9/44 10/44 Konflikt beheben git-kommandos: Austausch von Quellcode % cat test.txt hallo <<<<<<< HEAD welt! meine Version ======= Welt! Version in origin/master >>>>>>> 8ec6e9309fa37677e2e7ffcf9553a6bebf8827d6 sich für eine von beiden Versionen entscheiden Konflikt auflösen: % git add test.txt && git commit [master 4d21871] Merge branch master of /tmp/test % git push origin master Counting objects: 5, done. Writing objects: 100% (3/3), 265 bytes, done. Total 3 (delta 0), reused 0 (delta 0) Unpacking objects: 100% (3/3), done. To /tmp/test.git 8ec6e93..278c740 master -> master initiales Klonen: % git clone https://www4.cs.fau.de/... Einspielen entfernter Änderungen: % git pull äquivalent zu % git fetch && git merge Mehrere Repositories registrieren: % git remote add 32-stable git://git.kernel.org/.../... registrierte Remotes untersuchen: % git remote -v 11/44 12/44

git-kommandos: Austausch von Quellcode (Forts.) git-kommandos: Austausch von Quellcode (Forts.) alle Remotes nachladen (aktueller Branch wird nicht verändert) % git remote update lokalen Branch aus dem neuen "Remote anlegen: % git checkout -b work 32-stable/master Unterschiede zwischen lokalem und entferntem Branch untersuchen: % git log..origin/master aktuelle Änderungen auf dem entfernten Branch neu aufspielen: % git pull --rebase die neuste Änderung untersuchen: % git show die letzten drei Änderungen als Patch: % git format-patch HEAD~~ Sendeziel für Patchversand per E-Mail vorgeben: % git config sendemail.to=...@... Patchset letzten drei Änderungen per E-Mail senden: % git send-email --compose HEAD~~ einen Patch aus einer Mailbox anwenden: % git am < <Datei> herausfinden wer für welche Zeilen einer Datei verantwortlich ist: % git blame 13/44 14/44 Verzweigungen und Zusammenführungen Arbeitsablauf mit Branches Beispiel für parallele Entwicklung: In den meisten Versionsverwaltungssystemen i 2 3 4 5 6 7 2 3 4 5 m 1 Featurebranch anlegen 2 Feature im Branch implementieren, testen 3 Featurebranch mit master verschmelzen git commit git checkout -b git merge 4 ggf. Featurebranch löschen Naiver Ansatz skaliert nicht! 15/44 16/44

Warum branch/edit/merge nicht skaliert Lösung mit git: öffentlicher vs. privater Branch Aufgaben von Versionsverwaltung 1 Codeschreiben unterstützen 2 Konfigurationsmanagment/Branches z. B. Release-Version, HEAD-Version... Konflikt 1 braucht Checkpoint-Commits möglichst oft einchecken skaliert nicht 2 braucht Stable-Commits nur einchecken, wenn Commit perfekt nicht praktikabel Öffentlicher Branch verbindliche Geschichte atomar gut dokumentiert Commits sollen sein linear unveränderlich Privater Branch Schmierpapier für einzelnen Entwickler möglichst lokal wenn im zentralen Repo auf Privatheit einigen 17/44 18/44 Aufräumen verschmelze nie direkt privaten mit öffentlichem Branch Historie wird sonst unübersichtlich nicht einfach git merge im master machen i 2 3 4 5 6 7 vorher immer erst git 2 3 4 5 m rebase Commits auf Branch anwenden merge --squash einzelnen Commit aus Branch-Commits commit --amend letzten Commit überarbeiten Ziel: öffentlicher Commit Kapitel eines Buches Michael Crichton Great books aren t written they re rewritten. Arbeitsablauf für kleinere Änderungen git merge --squash zieht Änderungen aus einem Branch in den aktuellen Index Branch % git checkout -b private_feature_branch (Branch anlegen) % touch file1.txt file2.txt % git add file1.txt; git commit -am "WIP1" (file1.txt einchecken) % git add file2.txt; git commit -am "WIP2" (file2.txt einchecken) Merge % git checkout master (nach master wechseln) % git merge -squash private_feature_branch (Änderungen auf Index von master anwenden) % git commit -v (Änderungen einchecken) 19/44 20/44

git rebase <branch> git rebase <branch> Aufsetzen auf bestehenden <branch> Aufsetzen auf bestehenden <branch> i 2 3 4 5 i 2 3 4 5 2 3 4 5 Patches aus dem unteren Zweig werden auf den oberen aufgespielt Die Historie ist nun linear Linearisierte Änderungen lassen sich häufig einfacher bewerten Vorsicht! Verzweigungen vom alten Zweig können nicht mehr zusammengeführt werden Keine gemeinsamen Vorgänger mehr Visualisierung der Historie ist nun bestenfalls verwirrend 2 3 4 5 Patches aus dem unteren Zweig werden auf den oberen aufgespielt Die Historie ist nun linear Linearisierte Änderungen lassen sich häufig einfacher bewerten Vorsicht! Verzweigungen vom alten Zweig können nicht mehr zusammengeführt werden Keine gemeinsamen Vorgänger mehr Visualisierung der Historie ist nun bestenfalls verwirrend 21/44 21/44 git rebase -interactive <commit> Wenn der Feature-Branch im Chaos versinkt? schreibt Geschichte um git rebase -interactive ccd6e62ˆ pick übernimmt Commit pick ccd6e62 Work on back button pick 1c83feb Bug fixes pick f9d0c33 Start work on toolbar fixup verschmilzt Commit mit Vorgänger pick ccd6e62 Work on back button fixup 1c83feb Bug fixes # mit Vorgaenger verschmelzen pick f9d0c33 Start work on toolbar aufgeräumten Branch anlegen 1 auf Branch master wechseln % git checkout master 2 Branch aus master erzeugen % git checkout -b cleaned_up_branch 3 Branch-Änderungen in den Index und die Working Copy ziehen % git merge --squash private_feature_branch 4 Index zurücksetzen % git reset danach Commits neu zusammenbauen reword Beschreibung editieren edit kompletten Commit editieren git cola 22/44 26/44

git reflog Nützliche Aliase Zeigt die Befehlsgeschichte git reflog 8afd010 HEAD@{0}: rebase -i (finish): returning to refs/heads/master 8afd010 HEAD@{1}: checkout: moving from master to 8afd010ae2ab48246d5 7f97fab HEAD@{2}: commit: Pentax K20D fw version 1.04.0.11 wb presets 8c37332 HEAD@{3}: rebase -i (finish): returning to refs/heads/master 8c37332 HEAD@{4}: checkout: moving from master to 8c373324ca196c337dd 9d66ec9 HEAD@{5}: clone: from git://github.com/darktable-org/darkt....bashrc function git_current_branch() { git symbolic-ref HEAD 2> /dev/null sed -e s/refs\/heads\/// } # git push ohne tracking alias gpthis= git push origin HEAD:$(git_current_branch) # alle branches holen und dann rebase alias gup= git fetch origin && git rebase -p origin/$(git_current_branch) git reset --hard HEAD@{2} stellt alten Zustand wieder her https://gist.github.com/geelen/590895 27/44 28/44 Gliederung Gruppenrepositories Selbstverwaltet auf https://gitlab.cs.fau.de/ Account anlegen Regeln auf der Hauptseite beachten! Benutzernamen: wie auf Studentenausweis Repository anlegen Der Gruppe diy Zugriff auf das Repository geben Schreibrechte für die Gruppenmitglieder vergeben: Menüpunkt Members SSH Schlüssel für Authentifizierung hinterlegen % ssh-keygen -t rsa -f ~/.ssh/gitlab https://gitlab.cs.fau.de/help/ssh/readme 29/44 30/44

git-konfiguration des Repositories Lesenswertes zu git http://gitready.com.git/config [remote "origin"] fetch = +refs/heads/*:refs/remotes/origin/* url = git@gitlab.cs.fau.de:<username>/<projektname>.git [remote "vorgabe"] fetch = +refs/heads/*:refs/remotes/origin/* url = https://gitlab.cs.fau.de/diy/diy18-vorgabe.git http://book.git-scm.com/ http://gitcasts.com http://eagain.net/articles/git-for-computer-scientists/ http://sandofsky.com/blog/git-workflow.html http://365git.tumblr.com/ http://blog.sensible.io/post/33223472163/ git-to-force-push-or-not-to-force-push 31/44 32/44 Globale git-konfiguration des Systems Lesenswertes zu git $HOME/.gitconfig [user] name = Max Mustermann email = max.mustermann@fau.de [alias] co = checkout br = branch st = status unstage = reset HEAD -- visual =!gitk lg = log --graph \ --pretty=format: %C(red)%h%Creset -%C(yellow)%d%Creset %s %C(green)(%cr) %C(bold blue)<%an>%creset \ --abbrev-commit \ --date=relative http://gitready.com http://book.git-scm.com/ http://gitcasts.com http://eagain.net/articles/git-for-computer-scientists/ http://sandofsky.com/blog/git-workflow.html http://365git.tumblr.com/ http://blog.sensible.io/post/33223472163/ git-to-force-push-or-not-to-force-push 33/44 34/44

git-kommandos: Überblick git-kommandos: Überblick (Forts.) Repository erstellen: % git init Änderung hinzufügen: % git add <Datei> oder interaktiv: % git add -i feingranulares hinzufügen: % git add -p Änderungen einchecken: % git commit -i <Datei1> <Datei2>... alles was nicht im git ist löschen: % git clean -d <Pfad> nur anzeigen, was gelöscht werden würde: % git clean -n -d <Pfad> herausfinden was beim nächsten Commit verändert wird: % git diff --cached oder als Kurzzusammenfassung: % git status geänderte aber noch nicht eingecheckte Datei zurücksetzen: % git checkout -- <Datei> 35/44 36/44 git-kommandos: Überblick (Forts.) git-kommandos: Überblick (Forts.) das Log anschauen: % git log mit Graph: % git log --graph herausfinden, was im letzten Commit verändert wurde: % git whatchanged einen Commit rückgängig machen: % git revert <commit-id> Änderungen sichern, aber noch nicht einchecken: % git add... % git stash gesicherte Änderungen wieder hervorholen: % git stash apply Stashinhalt anzeigen: % git stash list Stash-Element löschen: % git drop <id> einen Branch anlegen: % git branch <Name> alle registrierten Branches anzeigen: % git branch -a zu einem Branch wechseln: % git checkout <Name> 37/44 38/44

git-kommandos: Überblick (Forts.) Gliederung menügeführt das Repository befragen I: % tig grafisch das Repository befragen II: % gitk Aktuelle Änderungen visualisieren: % meld. 39/44 40/44 Gitlab Dokumentation & Markdown Software zur Verwaltung von git-projekten Ählich zu github Accounts mit Studierendenkennung erzeugen DIY-Gitlab-Gruppe: https://gitlab.cs.fau.de/diy Demo? Einfache, leicht lesbare Auszeichnungssprache Direkt im Wiki des Gitlab-Repositories verwendbar Ideal geeignet für DIY-Dokumentation (Arbeitspakte, Tagebuch,... ) 41/44 42/44

Markdown Beispiel Fragen? # Überschrift 1 ## Überschrift 2 Text der Code-Fragmente enthält Oder auch längere Code-Listings: int main(void) { return 23; } *Kursiv*, **Fett** und ***Fett kursiv*** [inline-style link](https://www4.cs.fau.de) [relativer Link auf Datei im Repository](LICENSE) [absoluter Link auf Datei im Repository](/doc/kw42.md) 43/44 44/44