How Git Work: 01 - Git Is Not What You Think

The high-level commands in Git that users interact with, like add, commit, push, and pull. They are built on top of the plumbing commands.

The low-level commands in Git that provide the core functionality, like cat-file, hash-object. They are rarely used directly by users, but they are fundamental to Git's operation.

The internal structure and logic of how Git stores and manages data, including commits, branches, and objects.

A collection of files and directories that Git tracks, organized in a hierarchical tree structure. It can have multiple versions.

A snapshot of your project at a specific point in time. It records all the changes made to the files since the previous commit.

A separate line of development within a Git repository. Branches allow developers to work on different features independently without affecting the main codebase.

The act of combining changes from one branch into another. It merges the history of both branches into a single branch.

A way to integrate changes from one branch into another branch by rewriting the commit history.

A unique identifier, calculated from the content, used to track and identify a specific object in Git, such as a file, commit, or directory.

A specific sequence of bytes representing a piece of content in Git.

A command-line tool that generates a SHA1 hash for any input content.

The process of saving an object (content) in the Git repository, permanently associating it with its SHA1 hash.

A hidden directory within a Git repository that stores all the objects (content) and other metadata.

The likelihood of two different content files or objects generating the same SHA1 hash by chance.

A collection of files and directories that Git tracks and manages, organized in a hierarchical structure. It also contains the object database.

A command-line tool that initializes a new Git repository in a specified directory.

The process of adding files and directories to the staging area, making them ready for a commit.

The process of merging changes from one branch into another, combining their history into a single branch.

A command-line tool for showing the history of the current branch in the Git repository.

A visual representation of the commit history in the Git repository, showing branches, merges, and the relationships between commits.

A command-line tool for viewing the content of an object in the Git repository, using its SHA1 hash.

A version control system that tracks changes to files over time, but unlike traditional systems, it stores copies of the entire repository on each user's computer.

A system that records changes made to a set of files over time, allowing you to recover earlier versions or compare different states.

A term referring to a simple data structure where data is stored as key-value pairs.

The unique identifier generated by Git for any piece of content, like a file or commit.

A cryptographic hash function that Git uses to generate unique identifiers for content.

A Git command that allows you to output content to the standard output.

A pipe in the command line that allows you to redirect the output of one command as input to another command.

The standard input of a command, usually accessed using the > symbol.

A Git command used to switch between different branches in a repository.

A Git command that was historically used to switch between branches, but has been replaced by git switch in newer versions.

The history of changes made to a project, recorded in Git. You can explore past versions, see who made them, and compare them.

A generic piece of content stored in Git. It's created when you add a file to the repository and represents the file's contents.

A directory in Git where Git stores all its objects, including blobs, commits, and trees, using a hierarchical structure of folders and files.

The process of preparing files for inclusion in your next commit. It marks files as ready to be included in the snapshot.

A representation of a directory in Git. It stores information about the files and subdirectories within the directory.

A record that connects a commit to its parent commit(s). It forms a linked list of commits, representing the chronological order of changes.

The main branch of your Git repository. It typically represents the officially released state of your project.

A command used to check the current state of your Git repository. It shows which files have been changed, added, or deleted.

A command that adds files to the Git staging area, preparing them for inclusion in the next commit.

A command that creates a new commit based on the changes in the staging area. It records changes and adds a new snapshot to the project's history.

A special type of tag that includes additional information like a message, author, and date.

The internal structure and organization of objects in Git, which includes blobs, trees, commits, and annotated tags.

A way of storing objects in Git to save space by only storing changes between versions of a file or by compressing multiple objects into a single file.

A concept that emphasizes Git's ability to store objects in a way that allows retrieving past versions and tracking changes over time.

A high-level file system built on top of your native file system that leverages Git concepts like objects and commits to manage and track file versions.

A version control system that stores data as immutable objects, each identified by a unique hash. These objects represent individual files (blobs), directory structures (trees), and commit points (commits).

Changes in a file's content create a new blob object. Even files with identical content are not stored separately, Git re-uses existing blobs.

The root tree represents the top-level directory of the repository, connecting to all other files and directories in the project.

The hash of a commit is unique and changes even with small modifications in the files. This ensures immutability and integrity of the project history.

Commits are linked together through parent pointers, forming a chain of changes throughout the project's history.

A new commit creates a new tree that represents the current snapshot of the project. If the content of a directory hasn't changed, Git uses the existing tree object. However, if even a single file in the directory has changed, a new tree is created.

Git is efficient in storage as it re-uses existing blobs and trees with unchanged content.

Git's object database stores all the blobs, trees, and commits, forming a complete and chronological history of the project.

Versioning in Git is based on creating new commits for each change. Each commit points to a new tree, reflecting the changed state of the project.

A parent commit in a new commit represents the previous state of the project. This allows Git to track changes and trace the origin of any modification.