Software Engineering Roadmap

Learn how to build, test, deploy, and maintain robust software systems.

Overall Progress0%

Version Control (Git)

Explanation

In a professional team, Git is more than saving snapshots of your code. It is the coordination layer that lets many developers work on the same codebase safely: branches isolate work, pull requests enable review, and advanced commands like interactive rebase and git bisect keep history clean and help you find bugs. This lesson assumes you know the basics — init, add, commit, push. It focuses on the workflows and tools that professional engineers actually use: branching strategies, clean commit history, conflict resolution, hooks, and debugging with bisect. The goal is not to memorise commands but to understand the mental model behind them, so you can choose the right approach when your team’s repository gets complicated.

Git's Mental Model

Changes move forward through four areas. Understanding this explains nearly every Git command.

Working tree

↓

Staging area

↓

Commit

↓

Repository (and remote)

Branching and HEAD

A branch is a movable pointer to a commit. HEAD is a pointer to the branch you are currently on. When you commit, the branch pointer moves forward; HEAD stays attached to it.

Branching Strategies

	GitFlow	Trunk-Based Development
Branches	Long-lived develop + feature + release branches	Short-lived feature branches merged to main
Release	Dedicated release branches	Continuous releases from main
Overhead	Higher	Lower
Best for	Scheduled, multi-version releases	Fast, continuous delivery

Pull Requests

A pull request is a proposal to merge one branch into another. It creates a place for review, discussion, automated checks, and final approval before the merge.

Push your feature branch.
Open a pull request against main.
Reviewers comment and request changes.
Automated checks run.
Merge when approved.

Interactive Rebase and Squashing

Interactive rebase rewrites a branch’s commit history before it is merged, so the final history is clean. Squashing combines several small commits into one logical commit.

bash

1# Rebase the last 3 commits interactively2git rebase -i HEAD~33 4# In the editor: pick, squash, reword, or drop each commit

Conflict Resolution

Branch A + Branch B change the same lines

↓

Merge conflict

↓

Resolve manually

↓

Test

↓

Commit the merge

Git Hooks

Hooks are scripts Git runs automatically at certain events. A pre-commit hook can run a linter or formatter; a pre-push hook can run tests before code leaves your machine.

Git Bisect

When a bug was introduced at some unknown commit, git bisect performs a binary search over the history to find the first bad commit.

Known-good commit

↓

Test the middle commit

↓

Narrow the range

↓

First bad commit

Revert vs Reset

	git revert	git reset
What it does	Adds a new commit that undoes a change	Moves the branch pointer backward
History	Preserved	Rewritten
Safe on shared branches?	Yes	No

Reflog and Tags

The reflog records where HEAD has been, so you can often recover "lost" commits. Tags mark specific commits (for example, a release) with a stable name.

Good Commit Practices

One logical change per commit.
Write a clear, imperative message ("Add user login").
Keep commits small and reviewable.
Squash noisy work-in-progress commits before merging.

Syntax

Advanced Git commandsbash

1# Squash the last 3 commits2git rebase -i HEAD~33 4# Find a bug with binary search5git bisect start6git bisect bad        # current is broken7git bisect good v1.0  # known good8 9# Undo a change safely on a shared branch10git revert <commit>

git bisect checks out a middle commit; you mark it good or bad and it narrows down to the first bad commit.

Examples

Squash before merging

Combine three work-in-progress commits into one clean commit.

bash

1git rebase -i HEAD~32# mark the first as pick, the next two as squash

Output

History becomes: one squashed commit

Bisect a regression

Binary-search the history to isolate the bad commit.

bash

1git bisect start2git bisect bad3git bisect good v1.0

Output

Bisecting: 6 revisions left to test

Key Takeaways

Git moves changes: working tree → staging → commit → repository.
Choose a branching strategy that fits your release cadence.
Pull requests enable review, discussion, and automated checks.
Squash and rebase keep history clean — but only before sharing.
git bisect finds the first bad commit by binary search.
Revert preserves history; reset rewrites it.

← PreviousLanguage Fundamentals Next →Web Fundamentals