Version Control: Why We Need It, and the Basic Concepts of Git

What will we learn?#

• What Version Control is, and why every developer uses it.
• What Git is.
• The three areas: Working Directory, Staging Area, Repository.
• What a Commit is.
• The initial setup of Git.

Why do we need this?#

Do you know this folder?

project_final.py
project_final_v2.py
project_final_v2_WORKS.py
project_final_v3_dont_touch.py
project_final_v3_fixed_REALLY_FINAL.py

The problems:

• Which version works? What exactly changed between v2 and v3?
• “I broke something, and yesterday it worked!” How do you go back to yesterday’s state?
• Teamwork: two people edited the same file. How do you combine the changes without overwriting?
• Backup: the laptop was stolen. Is the project lost?

Version Control solves all of these. In every software company in the world, every line of code is managed with it. Without Git, you cannot work in a development team, and in a job interview they expect you to know it.

Explanation from the basics#

What is Version Control?#

Version Control is a system that records the history of the files: every change, when it was made, by whom, and why. You can go back to any point in the past, compare versions and combine the work of several people.

What is Git?#

Git is the most common version control system in the world, by a huge margin. It is:

• Local — the whole history is kept on your computer, in a hidden folder .git. It works even without internet.
• Distributed — every developer has a full copy of the whole history.
• Fast and free, and originally written by Linus Torvalds, the creator of Linux.

Git ≠ GitHub! Git is the tool that runs on your computer. GitHub is a website that hosts a copy of your Repository in the cloud, and adds tools for sharing and teamwork. We will meet it in the third lesson.

Repository#

Repository (Repo for short) = a project that Git tracks: the folder with the files, plus the hidden folder .git where the whole history is kept.

Commit — a snapshot#

Commit = a saved snapshot of the project at a certain moment, with:

• A message that explains what changed and why.
• An author (name and email) and a time.
• A unique identifier (Hash), for example a3f9c21.
• A reference to the previous Commit, and that is how a chain of history is formed.

(a3f9c21) ◄── (7b2e004) ◄── (e91d5aa)   ← HEAD (latest)
"Initial      "Add price     "Fix VAT
 project"      calculator"    rounding"

The three areas#

This is the most important concept in the lesson. Every file in the project is in one of three “areas”:

 Working Directory        Staging Area            Repository (.git)
 (the files you edit)     (ready for the next     (committed history)
                           commit)
       │                        │                        │
       │──── git add ──────────►│                        │
       │                        │──── git commit ───────►│
       │◄──────────────────── (checkout / restore) ──────│

Why is Staging needed? Because sometimes you changed 5 files, but only 3 of them belong to the same logical change (“fixing a bug in the calculator”). Staging lets you choose exactly what goes into each Commit, so that every Commit is one logical unit.

File states#

Syntax#

Installation: Git was installed on the first day of the course. Check: git --version.

One-time setup (once per computer). Git records the name and the email in every Commit:

git config --global user.name "Dana Cohen"
git config --global user.email "dana@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

Check:

git config --global --list

First code example#

Let’s see the idea of the “three areas” in commands. In the next lesson we will break each one down in depth.

mkdir ~\dev\kodkod6\git-demo
cd ~\dev\kodkod6\git-demo
git init

Output:

Initialized empty Git repository in C:/Users/dana/dev/kodkod6/git-demo/.git/

Now there is a Repository. The hidden folder .git was created. You can see it with ls -Force (PowerShell) or ls -a (Bash).

Breaking down the code line by line#

Another example#

The journey of one change, through the three areas, with git status after every step (the full details in the next lesson):

New-Item hello.py
git status
git add hello.py
git status
git commit -m "Add hello.py"
git status

Output (shortened):

Untracked files:
        hello.py

Changes to be committed:
        new file:   hello.py

[main (root-commit) 3c1f2a9] Add hello.py
 1 file changed, 0 insertions(+), 0 deletions(-)

nothing to commit, working tree clean

Common mistake#

Mistake 1: git init in the wrong folder, for example in the home folder (C:\Users\dana) or inside a folder that is already inside another Repository. Then Git tracks all the files on the computer, or confusing nested Repositories are created.

Always: cd to the project folder, pwd to make sure, and only then git init. And if you made a mistake: delete the hidden .git folder that was created by mistake (only it!).

Mistake 2: “I did git add, so it is saved.” No! add only prepares. Only commit saves into the history. And a change you made after the add is not included, until you add again.

Mistake 3: thinking that Git backs up to the cloud. Git is local. If the laptop is lost, the Repository is lost with it, unless you did a push to GitHub (lesson 3).

Mistake 4: not setting user.name / user.email.

Author identity unknown
*** Please tell me who you are.

Git refuses to make a Commit without knowing who the author is. Run the config commands from above.

Practice#

The exercises use only what was taught in this lesson and the lessons before it. Try on your own first, and only then open the solution.

Exercise 1: Why do we need version control?#

Danny’s folder has these files:

project_final.py
project_final_v2.py
project_final_v2_WORKS.py
project_final_v3_dont_touch.py

Give three problems with this method, and how Git solves each one.

Exercise 2: The three areas#

For each action — in which area is the change after it: the Working Directory, the Staging Area or the Repository?

1. You edited calculator.py and saved it.
2. You ran git add calculator.py.
3. You ran git commit -m "Add subtract".

Exercise 3: First setup#

Write the commands that set the name Dana Cohen and the email dana@example.com for Git, and then create a new Repository in the current folder. Why does Git need a name and an email?

git config --global user.name "Dana Cohen"
git config --global user.email "dana@example.com"
git init

Exercise 4: A chain of Commits#

(a3f9c21) <── (7b2e004) <── (e91d5aa)  <- HEAD
"Initial      "Add price     "Fix VAT
 project"      calculator"    rounding"

1. What is each of the identifiers a3f9c21, 7b2e004, e91d5aa?
2. What does HEAD point to?
3. Why does every Commit “point” to the one before it?

Exercise 5: Why do we need a Staging Area?#

Today you changed three things in the project: you fixed a bug in the calculator, improved the README, and added a temporary test file that you do not want to keep. How does the Staging Area help here?

Summary#

• Version Control records every change, and lets you go back, compare and work in a team. Git is the tool. GitHub is the website that hosts it in the cloud.
• Repository = a project + the hidden folder .git with the whole history.
• Commit = a snapshot with a message, an author, a time and an identifier (Hash).
• Three areas: Working Directory → (git add) → Staging Area → (git commit) → Repository.
• One-time setup: git config --global user.name / user.email.

Official documentation#

• Pro Git — About Version Control
• Pro Git — What is Git?
• Pro Git — First-Time Git Setup