Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Learn Git in a month of lunches
Umali R., Manning Publications Co., Greenwich, CT, 2015. 376 pp. Type: Book (978-1-617292-41-5)
Date Reviewed: Aug 31 2016

This book, the latest in Manning’s “In a Month of Lunches” series, offers software professionals an introduction to source control and Git. It is a welcome addition to the list of books dedicated to what might well be the most widely used source control system today. The “In a Month of Lunches” series from Manning Books is a series developed by Don Jones based on his principles of Immediately Effective Instruction, which address the problem of effectively training adults in technology. Books in this series comprise chapters that are meant to be read in an hour (specifically the “lunch hour”). A chapter can often include a few hands-on exercises to help reinforce items covered by the chapter.

This book adheres to the format of the series and comprises 20 chapters, which fall loosely into three sections.

The first ten chapters cover the basic concepts of version control and the basics of Git. They introduce readers to working with a repository, using the Git command line and the GUI that ships with Git, the staging area, branching, and Git’s log.

The next eight chapters cover the use of Git when collaborating with other people. This includes cloning repositories, keeping a repository up to date, pushing changes, using Git’s log to understand repositories featuring multiple contributors, conventions recommended when using Git, common workflows when using Git, and finally working with GitHub, the Git hosting service that has contributed significantly to Git’s popularity.

Chapter 19 is dedicated to third-party tools for working with Git. The author covers SourceTree and Eclipse, the tools he is most familiar with, and then offers a pointer to a more comprehensive list of tools available.

The final chapter is dedicated to the use of “git config” to configure different aspects of Git’s behavior and concludes with pointers to help readers improve their Git skills.

The author’s pace is gentle and patient. His tone is calm and there is no doubt that he really wants to make sure that the reader understands a concept that he is trying to explain. As he describes version control and Git (on Windows, Unix/Linux, and Mac), the author also devotes time to even explain the use of Unix commands and Vi, the default editor that Git is configured to use. His preface to the book introduces the underlying idea driving this approach: learn things slowly, which allows you to build both confidence and speed. He offers good analogies for Git’s staging area, a key feature that is tricky to understand and for merging branching in Git. He employs words, screenshots with annotations, and annotated outputs of commands. He often dedicates a chapter to just a single Git command and its useful options. This is a bold move that could have backfired and made the book seem like a stuffy tome, but to the author’s credit it works very well. All this makes the experience of reading this book feel like a good friend is teaching you.

Learning about Git’s internals has often been cited as a good way to understand how Git works. This approach unfortunately tends to work only for readers who are familiar and comfortable with reading about data structures and data models. This book does not attempt to explore Git’s internals at all. In doing so, it makes itself accessible to a much wider audience. Arguably, someone who has finished reading this book might even be in a better position to venture into learning about Git’s data objects after a solid foundation in using Git.

Books about software suffer from the inescapable problem of the referenced versions going out of date. The versions are reasonably current, when the book is written and published. This book is not immune to this problem, but it makes up for that by including notes about useful features available in newer releases of Git.

There aren’t many books that explain version control well. Eric Sink’s Version control by example, published in 2011 and available for free online [1], comes to mind. That book employed an engaging mix of illustrations and humor to explain various concepts of version control using four different systems (Subversion, Mercurial, Git, and Veracity). Rick Umali’s Learn Git in a month of lunches focuses on a single system, Git, and offers an encouraging, lucid introduction to what is a very powerful system that can be both fun and daunting to use.

More reviews about this item: Amazon, Goodreads

Reviewer:  George Thomas Review #: CR144717 (1611-0773)
1) Sink, E. Version control by example. http://ericsink.com/vcbe/ (08/20/2016).
Bookmark and Share
  Reviewer Selected
 
 
Version Control (D.2.7 ... )
 
Would you recommend this review?
yes
no
Other reviews under "Version Control": Date
Distributed version management for read-only actions
Weihl W. IEEE Transactions on Software Engineering 13(1): 55-64, 1987. Type: Article
Jan 1 1988
RCS--a system for version control
Tichy W. (ed) Software--Practice & Experience 15(7): 637-654, 1985. Type: Article
Apr 1 1986
Version control and separate compilation in Ada
Dausmann M.  Ada-components: libraries and tools (, Stockholm, Sweden, May 26-28, 1987)1701987. Type: Proceedings
Jan 1 1989
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy