Software Development. Using GIT. Pr. Olivier Gruber. Laboratoire d'informatique de Grenoble Université de Grenoble-Alpes

Size: px

Start display at page:

Download "Software Development. Using GIT. Pr. Olivier Gruber. Laboratoire d'informatique de Grenoble Université de Grenoble-Alpes"

Loren Goodwin
5 years ago
Views:

1 Software Development 1 Using GIT Pr. Olivier Gruber olivier.gruber@imag.fr Laboratoire d'informatique de Grenoble Université de Grenoble-Alpes

2 Overview 2 What is GIT Keeping histories of the evolution of files and directories The ability to merge histories, working alone or in a team Personal usage Protect and evolve your code Look at the past Team work Dividing work and be able to merge later Flexible cooperation

3 Real-life Scenarii 3 Personal usage examples Last minute, last change It started as a simple change, really Hum, what if... Team work examples Which USB key as the last version already? Trust me, I tested my changes... What? Fix you a bug now! Can t, in the middle of something Hey guys, sorry, but my machine died on me...

4 GIT concepts 4 GIT History A saga of transactions Tracks changes to a directory (its files and subdirectories) A transaction: do some work, then commit or abort init Git repo successive work sessions Work: create or delete directories create or delete files modify files c1 c2 c3 c4 commits Keep or toss your work

5 GIT concepts 5 GIT Repository A repository manages one tree of directories and files Git tracks the history of certain files and directories $ mkdir MyProject $ cd MyProject $ git init Initialized empty Git repository in../myproject/.git/ $ Git internal files Keeps previous versions of the tracked files MyProject ----.git ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo untracked files... tracked files...

6 GIT concepts 6 GIT Repository A repository manages one tree of directories and files Git tracks the history of certain files and directories MyProject ----.git ----.gitignore ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo give patterns to ignore Want to know more? $ man gitignore

7 GIT concepts 7 GIT Status Git tracks the history of certain files and directories Each file has a status untracked, tracked, modified MyProject ----.git ----.gitignore ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo tracked, unmodified untracked (new file) tracked, but modified status

8 GIT concepts 8 GIT Status Git tracks the history of certain files and directories Each file has a status untracked, tracked, modified, indexed MyProject ----.git ----.gitignore ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo Added to the index.. The index list all the files that are part of the current transaction

9 GIT concepts 9 GIT Status Git tracks the history of certain files and directories Each file has a status untracked, tracked, modified, indexed Commit: save changes for all the files in the index MyProject ----.git ----.gitignore ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo After the commit, these are now tracked and unmodified

10 GIT concepts Recap 10 Four commands Git-init Create a repository Git-status Give you the status of files Git-add Add files to the index Modified or untracked files Git-commit Want to know more? $ man git-init $ man git-status $ man git-add $ man git-commit Commit changes to indexed files

11 GIT concepts Recap 11 Four commands Git-init Create a repository Git-status Give you the status of files Git-add $ mkdir MyProject $ cd MyProject $ git init Initialized empty Git repository in../myproject/.git/ $ Add files to the index Modified or untracked files Git-commit Commit changes to indexed files

12 GIT concepts Recap 12 Four commands Git-init Create a repository Git-status Give you the status of files Git-add Add files to the index $... Add main.c Modify Makefile $ git status Modified: Makefile Untracked: main.c Modified or untracked files Git-commit Commit changes to indexed files

13 GIT concepts Recap 13 Four commands Git-init Create a repository Git-status Give you the status of files Git-add Add files to the index Modified or untracked files Git-commit Commit changes to indexed files $... Add main.c Modify Makefile $ git status Modified: Makefile Untracked: main.c $ git add all $ git status Makefile main.c

14 GIT concepts Recap 14 Four commands Git-init Create a repository Git-status Give you the status of files Git-add Add files to the index Modified or untracked files Git-commit Commit changes to indexed files $... Add main.c Modify Makefile $ git status Modified: Makefile Untracked: main.c $ git add all $ git status Makefile main.c $ git commit -m Added main.c $ git status nothing to commit, working directory clean $

15 GIT concepts Recap 15 File System View Developer View Index View Repo View MyProject ----.git ----.gitignore ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo Modified: Makefile Modified: foo.c Untracked: main.c History of all commits And the previous versions of tracked files

16 Using GIT for Oneself 16 For what? Permits trials and errors Provides a safety net Nothing is free Git maintains a history, so it requires space on your disk It takes some practice to getting used it

17 Using GIT Safety Net 17 Local safety net Git maintains a copy of your work in the.git directory So if you corrupt or loose a file/directory, you can recover it As long as you do not delete or damage the contents of the.git directory Remote safety net This is a bit more advanced usage You could clone your repository on a remote machine, used as a backed-up machine Example You could use your account at the UFR Or use github Or use another machine at home

18 Using GIT Safety Net 18 Git-checkout: revert changes Revert uncommitted changes Restore the contents of modified files Restore removed or renamed files or directories $ git add all $ git commit -m Task2 done Project/ Task1 Task2 Task3 Working on Task3 Ouch: - f***ed up file Toto.java - removed Titi.java $ git checkout Toto.java $ git checkout Titi.java...Finish Task3 Project/.git init checkouts c1 c2 c3 commits $ git add all $ git commit -m Task3 done

19 Using GIT Safety Net 19 Git-checkout: revert changes Revert all uncommitted changes only in tracked files Be careful here, you need to be sure before you ask for this it cannot be undone...working on Task2 $ git add all $ git commit -m Task2 done...working on OK, let s toss all that non sense... $ git checkout -f Project/ Project/.git init Task1 Task2 Task3 X c1 c2 commits checkout

20 Using GIT Safety Net 20 Git-checkout: revert changes, back several commits Revert all uncommitted changes in tracked files Oh oh Task2 and Task3 were a mistake Let s scratch that work. Project/ Task1 Task2 Task3 Task2 X X $ git log commit 75c027 c2 commit 35c025 c1 Project/.git init c1 c2 revert c3 $ git revert --no-commit 35c025..HEAD commits...now do it right $ git add --all $ git commit -m Ouf You can do it this way, but using branches is much easier...

21 Using GIT Branches 21 GIT history Branch: fork and merge your work Yields a tree of commits, on various branches master c1 c2 c8 c10 c13 branch-a c3 c7 WARNING: this may become complex branch-b branch-c c5 c4 c6 c9 c12 ADVICE: keep it simple branch-d c11 X

22 Using GIT branches 22 Switching between branches Changes the contents of tracked files Leaves untracked files untouched git checkout master git branch Task4 git checkout master MyProject ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo.org Untracked

23 Using GIT branches 23 Switching between branches Changes the contents of tracked files Leaves untracked files untouched git checkout master git branch Task4 git checkout master MyProject ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo.org MyProject ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo.org changed Untracked => unchanged

24 Using GIT branches 24 Switching between branches Changes the contents of tracked files Leaves untracked files untouched untracked object files... git checkout master git branch Task4 MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo.org

25 Using GIT branches 25 Switching between branches Changes the contents of tracked files Leaves untracked files untouched untracked object files... git checkout master git branch Task4 git checkout master MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo.org

26 Using GIT branches 26 Switching between branches Changes the contents of tracked files Leaves untracked files untouched untracked object files... checkout make clean git checkout master git branch Task4 git checkout master MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c --- main.c ---- Makefile ---- ToDo.org MyProject ---- bin --- foo.o --- bar.o ---- src --- foo.c --- bar.c ---- Makefile ---- ToDo.org changed

27 Using GIT branches 27 The simplest pattern Create a branch, merge it branch merge merge Delete the branch if no longer needed master $ git branch bug-fix $ git checkout bug-fix work on fixing the bug 1 bug-fix 2 3 X 2 $ git add all $ git commit -m Bug fixed commit delete 3 $ git checkout master Come back on the branch master 4 5 $ git merge bug-fix Merge the branch bug-fix into master No conflicts, if master is never worked on $ git add all $ git commit -m Bug fixed merged $ git branch -d bug-fix Optional delete of the branch

28 Using GIT branches 28 The simplest pattern A great safety net Create a branch, do some work branch Toss your work at any time... master 1 $ git checkout -b risky-try 1 3 work on trying something risky risky-try X 2 $ git add all $ git commit -m First commit commit 2 delete... If you do not like it at some point 3 $ git checkout master Come back on the branch master $ git branch -d risky-try Optional delete of the branch

29 Using GIT branches 29 What if your already started to work Then you realize this is going to be risky stuff No problem! (but avoid this situation nevertheless) started working stash & branch started working on something you are growing concerned just too risky master $ git stash $ git checkout -b risky-try $ git stash apply keep working Then comit or toss... risky-try commit or toss

30 Using GIT branches 30 Merge conflicts the hot-fix syndrome You are working on a new feature hoping for a few days of quiet dev-time Of course, a bug is found in your committed code a hot-fix is necessary When done with the hot-fix, you commit and merge onto master Going to you new new feature When done, can you merge to master? Hot-fix: merge and commit New-feature: merge master hot-fix merge with possible conflicts! new-feature

31 Using GIT branches 31 Always merge master on your local branch first Most updates on the same files are merged without conflicts Sometimes a manual merge is necessary You will need to practice it with your favorite merge tool Hot-fix: merge New-feature: merge master hot-fix $ git mergetool --tool=meld new-feature $ man git-mergetool merge and resolve conflicts

32 Using GIT branches 32 Merge conflicts Never merge on your master with potential conflicts... NEVER break your master! We mean it, NEVER! master X new-feature $ git mergetool --tool=meld $ man git-mergetool

33 Using GIT branches 33 Never break your master branch Never merge on your master with potential conflicts Always merge on your branch first... master new-feature $ git mergetool --tool=meld resolve conflicts, if any $ man git-mergetool

34 Using GIT branches 34 Never break your master branch Never merge on your master with potential conflicts Always merge on your branch first Always run regression tests before merging back on master master new-feature $ git mergetool --tool=meld $ man git-mergetool resolve conflicts, if any run regression tests

35 Using GIT branches 35 Safe Merge Workflow (1) run regression tests, they must pass before you can considering your work done (2) commit on your branch (3) merge the master branch on your branch (4) if the merge changed something goto (1) (5) merge your branch in the master branch master Final merge new-feature last commit always re-run regression tests run regression tests merge and resolve conflicts, if any last commit before merging with master

36 Using GIT branches 36 Safe Merge Workflow Using a merge branch Easy toss of the merge branch, if the merge should fail Easier if you ever need to checkout back and forth across branches (hot-fix for examples) master branch new-feature branch merge merge merge resolve conflicts, if any run regression tests

37 Using GIT Practice makes perfect 37 Do practice Again and again, until you are confortable with GIT Scared of making a mistake use branches Really scared try it on a copy of your project first Do not procrastinate Until you have a team project Keep it simple You will be happy you did, believe us Keep doing your backups Better safe than sorry Even if you use git clones

38 Using GIT Team Cooperation 38 Vera and John need to work together on a project They want to divide the work into features Develop features independently Vera Merge features incrementally Distributed Git Powerful and flexible tool Challenges Keep it simple! Really. Focus on keeping merges small and thus easy John

39 Using GIT Team Cooperation 39 Vera git-clone team-server git-clone John

40 Using GIT Team Cooperation 40 Cloning repositories across machines Create a repository (git-init), as a shared bare repository (--shared --bare) team-server $ mkdir -p /git-projects/projecta $ cd /git-projects/projecta $ git init --shared --bare Initialized empty shared Git repository in /git-projects/projecta $

41 Using GIT Team Cooperation 41 Cloning repositories across machines Team members clone that repository They get a local copy (called a clone) Vera git-clone team-server $ git clone vera@team-server:/git-projects/projecta $ cd ProjectA $ git-clone John

42 Using GIT Team Cooperation 42 Cooperation basics Vera does some work and publishes it John pulls Vera s work Vera $ cd ProjectA do some work does full testing $ git add all $ git commit -a -m Feature A $ git push git-server git-push John git-pull $ cd ProjectA $ git pull Now John sees Vera s work

43 Using GIT Team Cooperation 43 Challenges ALWAYS follow the same push-pull workflow STRIVE to keep merges small and thus easy NEVER break the repository pushing broken code Vera git-server git-push git-pull John

44 Using GIT Team Cooperation 44 1 new-feature 2 5 Vera master 4 git-merge 6 git-merge 3 git-pull 7 git-server 8 git-push Vera s Workflow: (1) create a branch to work in git checkout -b vera.feature.a (2) fully test and then commit git commit... (3) git pull from server clone git pull --all (4) merge master on your branch git merge master (5) fully test and then commit (6) git-merge on your master git checkout master; git merge vera.feature.a (7) tests and commit on master (8) git push

45 Using GIT Team Cooperation 45 Git-branch: new-feature merge conflicts Vera git-merge master git-merge git-pull git-push git-pull git-push git-server X rejected git-push

46 Using GIT Team Cooperation 46 Challenge of rejected git-push You may break the master on your clone But you can still fix it, test it, commit it, and then push it The pull-request pattern Only one team member does all merges on master Other team developers pull the master when starting a branch, from master, for a new feature

47 Using GIT Team Cooperation 47 Git-branch: Branch: vera.feature.a Branch: vera.feature.b Vera git-push master git-pull git-server git-pull git-push Branch: vera.feature.a John master git-merge git-merge

48 Using GIT Team Cooperation 48 Git-branch: Branch: vera.feature.a Checkout: vera.feature.a Vera git-push git-push master git-pull git-server git-pull git-push John Branch: vera.feature.a git-merge John rejects Vera s feature He returns it to Vera master

49 Conclusion 49 Git Powerful source control So keep it simple even simpler really we mean it! When to use it? Use it for your own personal development Use it for team development, but requires rigorous testing Practice it to learn it. Practice some more before using it on real projects... And do not forget, keep it simple. Really simple. Don t forget to backup your server repo

What is version control? (discuss) Who has used version control? Favorite VCS? Uses of version control (read)

What is version control? (discuss) Who has used version control? Favorite VCS? Uses of version control (read) 1 For the remainder of the class today, I want to introduce you to a topic we will spend one or two more classes discussing and that is source code control or version control. What is version control?