What Is Git?
Git is a free, open-source distributed version control system created by Linus Torvalds in 2005 to manage the development of the Linux kernel. Its design goals were speed, data integrity, and support for distributed, non-linear workflows involving thousands of parallel contributors. Rather than storing changes as a sequence of diffs against a single base, Git stores the state of your entire project as a series of snapshots. Each snapshot, or commit, records the full tree of files at that point, and unchanged files are stored as references to identical previous versions rather than being duplicated — making Git remarkably efficient despite tracking full snapshots.
Cricket analogy: Git's snapshot model is like a scorecard recording the entire match state after every over rather than just the delta of runs scored, and just as an unchanged fielding position isn't re-recorded each over, Git skips re-storing files that haven't changed, keeping the record efficient.
Origins and Design Goals
Before Git, the Linux kernel project used a proprietary tool called BitKeeper. When licensing arrangements broke down in 2005, Torvalds spent roughly ten days writing the first version of Git, explicitly prioritizing speed (handling a codebase with tens of thousands of files and a long history), a strong guarantee against silent data corruption, and a distributed model where no single server was a bottleneck. Every object in Git is checksummed with a SHA-1 (and increasingly SHA-256) hash, so any corruption or tampering is detectable — you cannot change a file's contents without Git noticing, because the hash of every downstream object would also change.
Cricket analogy: Torvalds writing Git in ten days is like a team building an emergency backup scoring system overnight after the official scoreboard software failed mid-tournament, prioritizing speed and tamper-proof accuracy — Git's SHA-1 checksums mean any silently altered run tally would be instantly detected.
Snapshots, Not Diffs
Many older systems think of stored information as a set of files and the changes (deltas) made to each file over time. Git thinks about its data more like a series of snapshots of a miniature filesystem: every time you commit, Git takes a picture of what all your tracked files look like and stores a reference to that snapshot. For efficiency, if a file has not changed, Git does not store it again — it simply links to the previously stored identical file. This snapshot model is what makes operations like branching and checking out a different point in history extremely fast, since Git is largely just rearranging pointers rather than replaying a long chain of diffs.
Cricket analogy: Older systems track a match like a running commentary of deltas ('two runs, then a wicket'), while Git takes a full scoreboard photograph after every ball; if the fielding positions haven't changed, it just references the previous photo instead of redrawing the whole field, making replay-through-history fast.
Git's name is a self-deprecating British slang term Torvalds chose (his own joke: 'I'm an egotistical bastard, and I name all my projects after myself. First Linux, now Git.'). Functionally it stands for nothing — it is simply a short, easy-to-type, distinctive name.
# Check the installed Git version
git --version
# git version 2.44.0
# See how Git identifies itself and confirm basic setup
git config --global user.name "Ada Lovelace"
git config --global user.email "[email protected]"
# Ask Git to explain any command
git help commitGit vs. GitHub
A common point of confusion for beginners: Git is the version control tool itself, running locally on your machine, while GitHub (along with GitLab, Bitbucket, and similar services) is a hosting platform built around Git that adds collaboration features — pull requests, issue tracking, code review, CI integration, and a social layer for discovering projects. You can use Git fully without ever touching GitHub (for example, hosting your own remote on a private server), and understanding this separation clarifies which concepts are Git-native (commits, branches, merges) versus platform-specific (pull requests, project boards).
Cricket analogy: Git is like the bat and technique a player uses locally in the nets, while a hosting platform like GitHub is like the stadium and broadcast infrastructure that adds crowds, commentary, and a scoreboard — you can practice fully with just the bat, but the stadium adds the social, spectator layer.
- Git is a distributed version control system created by Linus Torvalds in 2005 for Linux kernel development.
- Git's core design goals are speed, data integrity via cryptographic checksums, and support for fully distributed workflows.
- Git stores project history as a series of full snapshots, not incremental diffs, reusing unchanged file data for efficiency.
- Every Git object is checksummed (SHA-1/SHA-256), making silent corruption or tampering detectable.
- Git is the underlying tool; GitHub and similar platforms are hosting and collaboration services built on top of it.
Practice what you learned
1. Who created Git, and for what original purpose?
2. How does Git primarily represent the history of a project?
3. What mechanism does Git use to detect data corruption or tampering?
4. Which statement correctly distinguishes Git from GitHub?
5. Why is Git considered efficient with storage despite tracking full snapshots at every commit?
Was this page helpful?
You May Also Like
What Is Version Control?
An introduction to version control systems, why teams need them, and the difference between centralized and distributed approaches to tracking change over time.
The Git Object Model
A deep dive into how Git stores data internally as blobs, trees, commits, and tags — the content-addressable database underlying every Git operation.
The Three States of Git
Understand Git's core mental model — working directory, staging area, and repository — and how files move between them during a typical edit-commit cycle.
Installing and Configuring Git
How to install Git on major platforms and configure identity, editor, and behavior settings at the system, global, and local levels.
Related Reading
Related Study Notes in Software Engineering
Browse all study notesMicroservices Study Notes
Software Architecture · 30 topics
Software EngineeringTesting & TDD Study Notes
Software Testing · 30 topics
Software EngineeringDesign Patterns Study Notes
Software Design · 30 topics
Software EngineeringSoftware Engineering Study Notes
Python · 75 topics
Software EngineeringSystem Design Study Notes
Architecture · 46 topics