Pro Git: Everything You Need to Know About Git (English)
Reviewed by Javier Burroni, Lecturer, Smith College on 2/25/26
Comprehensiveness
The text covers Git comprehensively, from everyday commands (adding, committing, branching) through advanced topics such as submodules, server setup, contributing workflows, and Git internals. If something can be done with Git, it is most likely described in this book. The text is best understood not as a beginner's tutorial but as a thorough treatment of Git aimed at readers who have some prior experience and want to deepen their understanding. For that audience, the breadth and depth of coverage is excellent.
Content Accuracy
The technical content is accurate and reliable throughout. Commands, options, and workflows are described correctly, and the book reflects how Git actually works in practice.
Relevance/Longevity
Git is the dominant version control system and is likely to remain so for the foreseeable future. The content is broadly current. One area that could benefit from attention in future editions is the treatment of `git restore`, a command introduced in 2019 to replace certain uses of `checkout` and `reset`. The book contains passages that cover both the old and new approaches, but without clearly distinguishing between them, which can be confusing for readers. This is a minor issue and would be straightforward to address in an update. The modular structure of the book should make such revisions relatively easy to carry out.
Clarity
Clarity varies across the book. Some chapters are excellent: the chapter on branching uses a fictional scenario that makes the concepts concrete and easy to follow, and the "Reset Demystified" section is a model of clear technical writing, with diagrams that make the material accessible. The chapters on contributing workflows are similarly well done.
Other sections, particularly the earlier introductory chapters, read more like exhaustive documentation than pedagogical material. A recurring pattern in the book is presenting complex or obscure approaches before simpler, recommended ones. For example, deleting remote tags is first shown using the less intuitive `git push :refs/tags/` syntax before the simpler `git push origin --delete `. Similar patterns appear in the treatment of submodules and branch checkout. This ordering can be disorienting for less experienced readers.
The book also tends to treat rare and common use cases with equal weight. For instance, it describes fetching from multiple remote repositories before covering the far more common case of a single cloned remote. This makes it difficult for students to know what to prioritize.
As a general observation, sections that include diagrams tend to be the clearest. The "three trees" conceptual model, which is very helpful for understanding the purpose of `add` and `commit`, appears relatively late in the book and would benefit beginners if introduced earlier.
Consistency
The writing quality varies noticeably across chapters. Some are pedagogically strong, using scenarios, diagrams, and clear motivations. Others are dense, reference-style catalogs of commands and options. Comparisons with other version control systems appear unevenly: Subversion is discussed in several places, but Mercurial, the system most architecturally similar to Git, is largely absent from the comparative discussions in the main chapters and only surfaces briefly in a later section.
Modularity
The book is well structured into chapters and sections that can be assigned independently. An instructor could assign Chapter 2 for basics, Chapter 3 for branching, and the contributing chapter for workflow discussions without requiring students to read the entire book sequentially.
Organization/Structure/Flow
The overall topic sequence is logical, moving from basics to branching to server setup to workflows to advanced topics and internals. Within chapters, though, the recurring pattern of presenting complex solutions before simple ones can disrupt the learning flow. Key conceptual frameworks, such as the "three trees" model, appear later in the book rather than in the introductory material where they would be most helpful for building understanding.
Interface
The text is well formatted, with clear code blocks, command examples, and diagrams.
Grammatical Errors
No significant grammatical issues were noted.
Cultural Relevance
The text raises no concerns regarding cultural sensitivity or inclusivity.
CommentsThis is a very good book on Git. It is thorough, technically accurate, and several of its chapters are genuinely outstanding as teaching material. Professionals and technical team leaders will find it especially valuable: the detailed treatment of workflows, branching strategies, and policy enforcement provides material that can be directly applied to improve team practices.
For an introductory course, an instructor should be prepared to curate which sections to assign and in what order, as the book does not always prioritize the most common use cases. Students encountering Git for the first time may benefit from a more focused tutorial alongside the relevant chapters of this text.
A suggestion for a future edition: it would be valuable to cover workflows involving multiple working trees attached to the same repository (using `git worktree`), a pattern that has become increasingly common with the rise of agentic AI development tools.