Git. It’s the lifeblood of modern software development. After several years of navigating through code repositories and juggling various project versions, it’s easy for seasoned developers to settle into a comfortable routine with familiar tools. Git, the ubiquitous version control system, is no exception to this rule. It’s a tool that many of us use almost mechanically. However, a recent blog post on Appwrite’s blog titled “10 Git Commands You Should Start Using” opened my eyes to a suite of commands that could significantly streamline my daily tasks. We talked about this blog post on the PHP Podcast 2025.01.02, but let’s dive into their post a little more here.

The Power of Evolution in Git

Git has evolved considerably since its inception, continuously adding features that address the growing complexity of software development. However, many developers (myself included) cling to the basic commands (git add, git commit, git push) without exploring the depth of Git’s capabilities. This oversight can lead to inefficient workflows and a failure to leverage Git’s full potential.

Commands Worth Embracing

From the blog post, several commands stand out for their potential to change how developers interact with their repositories. Here are a few highlighted in the article that I found particularly transformative:

1/2. git switch and git restore

Replacing the old git checkout, these commands offer a more intuitive way to switch branches and restore file states. The separation of concerns—switch for branches and restore for files—makes for a clearer, more logical workflow in managing changes.

3. git maintenance

This command, introduced in Git 2.29, automates essential repository optimization tasks to prevent performance degradation as repositories grow. By running git maintenance start and git maintenance run, it performs garbage collection to remove unreachable objects, repacking to consolidate fragmented packfiles, and updates the commit graph to optimize command execution speeds like git log and git blame. This functionality ensures the repository remains efficient without the need for manual intervention.

4. git sparse-checkout

Introduced in Git 2.25, enhances efficiency in handling large repositories, especially monorepos. It allows users to selectively clone and manage specific directories or files rather than the entire repository. By initiating git sparse-checkout init and specifying desired directories with git sparse-checkout set, users can significantly reduce the amount of data cloned, saving both time and disk space. This is particularly advantageous for large teams where members may only need access to certain parts of a repository.

5. git log –remerge-diff

Introduced in Git 2.35, enhances the understanding of merge commits. This command replays the merge strategy used during the commit and displays the specific changes it introduced. It’s particularly useful for debugging merge conflicts and reviewing complex merge histories, offering insights into how conflicts were resolved and the exact contributions of each branch in a merge.

6. git blame –ignore-rev

Introduced in Git 2.23, the –ignore-rev option for the git blame command helps maintain the utility of tracking original authorship, even after bulk formatting changes. By specifying commit hashes to ignore, such as those that change formatting, you can ensure git blame points to the substantive contributions rather than formatting commits. This is achieved by creating an .git-blame-ignore-revs file to persistently exclude specified commits, allowing for more accurate authorship tracking in codebases with frequent stylistic updates.

7. git range-diff

The git range-diff command, useful for comparing two commit ranges, offers insights into how commits evolve following operations like rebasing or cherry-picking. It highlights changes between the original and rewritten commits, making it easier to understand the modifications made during the development of a feature or the resolution of a bug across different branches. This command is particularly valuable for reviewing changes in detail and ensuring that the intended adjustments are accurately applied during complex Git operations.

8. git worktree

This was actually one I had heard of, and a good friend who works on PHP internals was nice enough to explain to me. Probably not a command you would use on your run a the mill PHP application repo, the git worktree command enhances productivity by allowing developers to manage multiple branches simultaneously without disrupting the main working directory. This feature lets you add separate working directories for different branches, enabling you to work on them concurrently. It’s especially useful for isolating builds, deployments, or testing in distinct environments. You can easily add a new worktree linked to a specific branch and remove it once your task is completed, thereby maintaining a clean and efficient development workflow.

9. git rebase –update-refs

Introduced in Git 2.38, this automates the synchronization of branch pointers and tags when rebasing alters commit history. This feature ensures that references are automatically adjusted to reflect rewritten commits, thereby maintaining consistency across your repository without manual intervention. For enhanced convenience, you can configure Git to always update references during rebasing by setting git config rebase.updateRefs true, making it highly beneficial for collaborative projects or when managing multiple references.

10. git commit –fixup and git rebase –autosquash

The git commit –fixup and git rebase –autosquash commands provide a streamlined way to maintain clean commit histories. Introduced in Git 1.7.4, these tools automate the inclusion of minor fixes or improvements to previous commits, reducing the risk of errors during manual history edits. By creating a fixup commit with git commit –fixup=<commit-hash> and automatically squashing these during an interactive rebase using git rebase -i –autosquash <base-branch>, developers can efficiently organize related changes before merging, enhancing the clarity and coherence of commit logs.

The Developer’s Journey with Git

Adopting new commands can be daunting, particularly when old habits are deeply ingrained. However, the effort to learn and integrate these tools can pay off immensely. Each new command learned is a step toward more efficient, effective version control practices.

For those hesitant to dive into newer Git features, I recommend starting small. Integrate one new command into your workflow each week. Monitor how it affects your efficiency and adaptability. Often, you’ll find that these new tools solve problems you didn’t even realize were holding you back.

The blog post on Appwrite’s website is more than just a tutorial; it’s a call to action for developers to evolve alongside their tools. Git is powerful, but only as powerful as the user’s knowledge of its capabilities. By embracing these new commands, developers can ensure they are maximizing their productivity and embracing best practices in version control.

Whether you’re a novice just starting out with Git or a seasoned developer set in your way, there’s always room to grow and improve. The journey of mastering Git is ongoing, and each new command learned is another tool in your arsenal to tackle the challenges of modern software development.

Do yourself a favor and get the Appwrites blog post today and tey something new with your git workflow.

Blog Post: https://appwrite.io/blog/post/10-git-commands-you-should-start-using