Reading History: log, diff, show and Navigating the Past

Commit History as a Project Diary

• Git log shows history as an inverted diary
• Each entry is a snapshot of changes
• Stores who changed what and when
• Allows you to see code evolution

Imagine that every time you save changes in Git, you're making an entry in a development diary. The 'git log' command shows these entries in reverse chronological order - from newest to oldest. This diary contains the complete project chronology: who made which changes and when. It's not just a list of changes, but a living history of your code's evolution. The ability to read and analyze this history is a key skill for teamwork. After all, it's through commit history that you see how the project developed, what decisions were made and why. Let's take a closer look at the structure of an individual commit.

Reading a Commit: Hash, Author, Date

• commit: unique hash identifier
• Author: who made the changes and when
• Date: commit timestamp
• Message: what exactly was changed

Look at the output of the 'git log' command. Each entry begins with a long string of characters - this is the commit hash, its unique identifier. To the right, you'll see the author of the changes and when they were made. Below that is the commit message that the developer wrote when saving the changes. Note the format: first comes the author's email in angle brackets, then the timestamp. This data helps understand the context of changes and, if necessary, contact the author for clarification. Now that we've examined the structure of a commit, let's understand what a hash is and why we need it.

#!/bin/bash
cd ~/projects/git-course/
git log -1 --pretty=format:'commit %H%nAuthor: %an <%ae>%nDate:   %ad%n%n    %s'

Commit Hash - Your Key to History

• A hash is a digital fingerprint of a commit
• Depends on content and metadata
• Changing even one character alters the hash
• Allows precise referencing of any version

A commit hash isn't a random string of characters but the result of a cryptographic function that transforms commit contents into a unique string. If you change even a single byte in the commit, the hash will change completely. This ensures the integrity of the change history. Knowing the hash is like having a precise bookmark - you can reference any version of the code. For example, the 'git checkout' command with a specific hash will take you to the project's state at that commit. This is particularly useful when you need to roll back changes or analyze when a bug was introduced. Now that we understand the structure of history, let's learn how to filter it - because in real projects, there can be thousands of commits.