Git Snapshot | Steps | Workflow — 2

M. Safarian — Wed, 20 Mar 2024 06:39:48 +0000

In previous article, I covered the fundamental commands and steps necessary to create Git snapshots, also known as “committing changes”. However, in this piece, I aim to delve deeper into the report generated by Git after a commit, Git objects, how Git works under the hood

lets recap

In the diagram below, we illustrate the workflow for committing a new file in Git:

After committing changes, Git provides us with a commit report. In this section, we’ll delve into the significance of the SHA-1 checksum, decipher the meaning of the last line in the report, and explore the inner workings of Git’s commit process.

$ git commit -m "this is init commit"

[master (root-commit) ed942fe] this is init commit
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 example.txt

First and foremost, it’s important to emphasize that Git captures snapshots of files, rather than recording the differences between versions. In other words, Git focuses on snapshots, not on differences (diffs) between versions. SNAPSHOT not DIFFS.

Today, we will learn new terminologies and some commands that are not necessary during software development, but they allow us to understand Git’s operations under the hood.

Git Objects

If you’ve worked with key-value databases like Redis before, the core concept of Git is easy to understand. Git functions as a key-value data storage system, allowing you to store various types of content and providing a unique hash string as a key in return. This hash string, typically of type SHA-1, enables you to retrieve the contents later.

lets start with create a fresh local repository, after ‘init’ commad git creates a directory in of ‘.git’.

$ git init example

Initialized empty Git repository in /home/mehdi/git/example/.git/

In simple terms, the database I mentioned earlier will be located in the ‘.git’ directory. If you head to the ‘.git/objects’ directory, you’ll see ‘info’ and ‘pack’ subdirectories. They are belongs to Git and this is the place that Git uses as their object database.
When you start a fresh repository there is nothing in ‘objects’ direcotry.
There is a ‘hash-object’ command which create a data object and we can manually store data in Git key-value database and in return gives us a 40 character hash string in SHA-1.

Before that, let’s check the ‘objects’ directory with the following command. As of now, it will return nothing.

$ find .git/objects -type f

Now, we’ll proceed to create our first data object manually using the ‘hash-object’ command. We’ll include additional flags like ‘-w’, which stands for write and indicates that we’re writing content into the database, and ‘-stdin’, which means we’ll read from stdin or the command-line.

$ echo 'Hello im mehdi' | git hash-object -w --stdin
4086ef4e53b8c4ab5a6aa37833db8c6c5032cf9d

lets check the ‘objects’ directory

$ find .git/objects -type f
.git/objects/40/86ef4e53b8c4ab5a6aa37833db8c6c5032cf9d

My ‘Hello, I’m Mehdi’ is stored in the Git database as an object. I can retrieve this data using the ‘cat-file’ command. The first two characters of the hash string represent the object directory, while the rest is a simple blob file, which I’ll discuss in the next part. Lets try to retrive our object in human readable output.

$ git cat-file -p 4086ef4e53b8c4ab5a6aa37833db8c6c5032cf9d
Hello im mehdi

Good, Lets keep it short.

In conclusion

we’ve explored the foundational concepts of Git, including its snapshot-based approach and key-value database structure. Understanding these core principles. We’ve also familiarized ourselves with new Git commands and terminologies, providing a solid foundation for further exploration and mastery of this powerful version control system. In next part we will read about “tree object” and blob files.

Git Snapshot | Steps | Workflow — 1

M. Safarian — Wed, 20 Mar 2024 06:23:44 +0000

While many people perceive Git as a confusing and complicated tool, it's actually quite simple once you become more familiar with it. Like many other areas of knowledge, all it takes is getting accustomed to it. Trust me, it's not as tangled as quantum physics.

Steps to create snapshot

In order to snapshotting a working directory, there are some basic commands.
$ git status $ git add $ git commit

These tree commands represent two basic steps for capturing a snapshot of your working directory. While the 'status' command is merely informational, it's still beneficial to understand what it reveals about your actions :)
lets imagine we created a repository in our local system and now we are going to add a file into them.
first we check the status of our local repository by using 'status' commad:

git status
On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
 example.txt

nothing added to commit but untracked files present (use "git add" to track)

As we can see, there is nothing on our stage, and the file 'example.txt' is under the 'Untracked files' category. This generally indicates that Git doesn't care about that file until we add it to the stage and create a new snapshot. After that, Git will monitor all files that have taken at least one snapshot.
The 'add' command is used to stage files, thereby indicating Git's awareness of them.

git add example.txt

Let's check the status of our repository again to see what has changed.

git status

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
 new file:   example.txt

At this point, Git is actively tracking the file and is prepared to capture a snapshot of it, or in other words, the file is ready to be committed.
lest see this workflow in a diagram.

For our final action, we are going to create a commit message, and Git will take a snapshot of the current state of the repository.
The '-m' flag allows us to use an inline commit message. Without it, Git will open the system's default editor(vscode, nano, vim, etc…).

git commit -m "this is init commit"

[master (root-commit) ed942fe] this is init commit
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 example.txt

Congratulations, you've done it!
That's precisely what's needed to keep track of changes to our files.
In return, Git provides a report of what was committed. I'll discuss the details of this report in a separate document. However, generally, this report informs us that we committed on the master branch, and the SHA-1 checksum is 'ed942fe'. We can use this checksum to 'check-out' between our snapshots. In other words, this checksum is the signature of our snapshot, allowing Git to locate your target snapshot.

In conclusion

Git stands as one of the most prominent tools in the software world, particularly among programmers. Throughout this process, we've acquired the knowledge of adding new files to the staging area and committing changes, laying the groundwork for effective version control and collaboration in our software projects.

DEV Community: M. Safarian

Git Snapshot | Steps | Workflow — 2

lets recap

Git Objects

In conclusion

Git Snapshot | Steps | Workflow — 1

Steps to create snapshot

In conclusion