What is Git - Visual Explanation

Process Flow - What is Git

Start: Create Project Files

↓

Initialize Git Repository

↓

Track Changes with Git

↓

Commit Changes

↓

View History

↓

Collaborate by Sharing Repository

↓

Update and Commit Again

↓

Repeat as Project Grows

This flow shows how Git tracks changes in a project from start to collaboration by saving snapshots called commits.

Execution Sample

Git

git init
# Initialize a new Git repository

git add .
# Stage all files for commit

git commit -m "Initial commit"
# Save snapshot of current files

This code initializes a Git repository, stages all files, and commits them as the first snapshot.

Process Table

Step	Command	Action	Result
1	git init	Create .git folder to track project	Repository initialized, ready to track changes
2	git add .	Stage all current files for commit	Files are marked to be saved in next commit
3	git commit -m "Initial commit"	Save snapshot of staged files	Commit created with message 'Initial commit'
4	git status	Check repository status	No changes to commit, working directory clean

💡 No more commands; repository is set up and initial files are saved

Status Tracker

Variable	Start	After git init	After git add .	After git commit
Repository State	No Git tracking	Git folder created	Files staged for commit	Files committed (snapshot saved)

Key Moments - 2 Insights

Why do we need to run 'git add' before 'git commit'?

'git add' tells Git which files to include in the next snapshot. Without adding, 'git commit' saves nothing new. See execution_table step 2 and 3.

What does 'git init' actually do?

'git init' creates a hidden folder (.git) that stores all information Git needs to track changes. It does not save files yet. See execution_table step 1.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after running 'git init'?

A Repository initialized, ready to track changes

B Files are marked to be saved in next commit

C Commit created with message 'Initial commit'

D No changes to commit, working directory clean

💡 Hint

Check the 'Result' column for step 1 in the execution_table

At which step are files actually saved as a snapshot in Git?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table step 3

If you skip 'git add' and run 'git commit' directly, what happens?

A Git saves all files automatically

B Git saves only previously staged files

C Git shows an error and stops

D Git deletes all files

💡 Hint

Refer to key_moments about the role of 'git add' before 'git commit'

Concept Snapshot

Git is a tool to track changes in project files.
Use 'git init' to start tracking.
Use 'git add' to select files to save.
Use 'git commit' to save snapshots.
Snapshots let you see history and collaborate.

Full Transcript

Git helps you save versions of your project files. First, you create files. Then, you run 'git init' to start a Git repository. This creates a hidden folder to track changes. Next, you use 'git add' to tell Git which files to save. Finally, 'git commit' saves those files as a snapshot with a message. You can check status anytime with 'git status'. This process repeats as you update your project, letting you keep history and work with others.

Practice

1. What is the main purpose of Git?

easy

A. To create websites from scratch

B. To edit images and videos

C. To save and track changes in files over time

D. To manage computer hardware settings

Solution

1. Step 1: Understand Git's role

   Git is a tool designed to save and track changes in files, especially code files.

2. Step 2: Compare options

   Options B, C, and D describe tasks unrelated to Git's main function.

3. Final Answer:

   To save and track changes in files over time -> Option C

4. Quick Check:

   Git = tracks file changes [OK]

Hint: Git tracks file changes, not edits or hardware [OK]

Common Mistakes:

• Confusing Git with editing software
• Thinking Git manages hardware
• Believing Git builds websites

2. Which of the following is the correct command to start a new Git repository?

easy

A. git start

B. git init

C. git create

D. git begin

Solution

1. Step 1: Recall Git commands

   The command to create a new Git repository is git init.

2. Step 2: Check other options

   Commands like git start, git create, and git begin do not exist in Git.

3. Final Answer:

   git init -> Option B

4. Quick Check:

   Initialize repo = git init [OK]

Hint: Use 'git init' to start a repo, others are invalid [OK]

Common Mistakes:

• Using 'git start' instead of 'git init'
• Confusing command names
• Trying commands that don't exist

3. What will be the output of the command git status right after running git init in a new folder?

medium

A. No commits yet, nothing to commit, working tree clean

B. Error: repository not found

C. All files are staged for commit

D. Untracked files present, please add them

Solution

1. Step 1: Understand 'git init' effect

   Running git init creates an empty Git repository with no commits.

2. Step 2: Check 'git status' output

   Right after init, git status shows "No commits yet" and "working tree clean" because no files are added or changed.

3. Final Answer:

   No commits yet, nothing to commit, working tree clean -> Option A

4. Quick Check:

   git status after init = no commits, clean [OK]

Hint: After init, status shows no commits and clean tree [OK]

Common Mistakes:

• Expecting errors after init
• Thinking files are staged automatically
• Assuming untracked files message appears immediately

4. You ran git add file.txt but forgot to commit. What will git status show?

medium

A. Changes to be committed: new file: file.txt

B. No changes detected

C. Untracked files: file.txt

D. Error: file.txt not found

Solution

1. Step 1: Understand 'git add' effect

   Running git add file.txt stages the file for commit but does not commit it yet.

2. Step 2: Check 'git status' after add

   git status will show the file under "Changes to be committed" because it is staged.

3. Final Answer:

   Changes to be committed: new file: file.txt -> Option A

4. Quick Check:

   git add stages files, status shows staged changes [OK]

Hint: Added files show as staged, not committed yet [OK]

Common Mistakes:

• Thinking add commits files
• Expecting untracked files after add
• Assuming no changes after add

5. You want to save your changes permanently in Git. Which sequence of commands should you run?

hard

A. git init then git push

B. git commit -m "message" then git add .

C. git status then git push

D. git add . then git commit -m "message"

Solution

1. Step 1: Stage changes with 'git add'

   You first use git add . to stage all changes in the current folder.

2. Step 2: Commit staged changes

   Then run git commit -m "message" to save the staged changes permanently with a message.

3. Final Answer:

   git add . then git commit -m "message" -> Option D

4. Quick Check:

   Stage then commit = add then commit [OK]

Hint: Always add before commit to save changes [OK]

Common Mistakes:

• Committing before adding files
• Using push without commit
• Initializing repo unnecessarily