Version Control with Git: Powerful Tools and Techniques for Collaborative Software Development [Paperback]

Jon Loeliger (Author)

Book Description

Publication Date: June 11, 2009 | ISBN-10: 0596520123 | ISBN-13: 978-0596520120 | Edition: 1

Version Control with Git takes you step-by-step through ways to track, merge, and manage software projects, using this highly flexible, open source version control system.

Git permits virtually an infinite variety of methods for development and collaboration. Created by Linus Torvalds to manage development of the Linux kernel, it's become the principal tool for distributed version control. But Git's flexibility also means that some users don't understand how to use it to their best advantage. Version Control with Git offers tutorials on the most effective ways to use it, as well as friendly yet rigorous advice to help you navigate Git's many functions.

With this book, you will:

• Learn how to use Git in several real-world development environments
• Gain insight into Git's common-use cases, initial tasks, and basic functions
• Understand how to use Git for both centralized and distributed version control
• Use Git to manage patches, diffs, merges, and conflicts
• Acquire advanced techniques such as rebasing, hooks, and ways to handle submodules (subprojects)
• Learn how to use Git with Subversion

Git has earned the respect of developers around the world. Find out how you can benefit from this amazing tool with Version Control with Git.

Editorial Reviews

About the Author

Jon Loeliger is a freelance software engineer who contributes to Open Source projects such as Linux, U-Boot, and Git. He has given tutorial presentations on Git at many conferences including Linux World, and has written several papers on Git for Linux Magazine.

In prior lives, Jon has spent a number of years developing highly optimizing compilers, router protocols, Linux porting, and the occasional game. Jon holds degrees in Computer Science from Purdue University. In his spare time, he is a home winemaker.

Product Details

• Paperback: 330 pages
• Publisher: O'Reilly Media; 1 edition (June 11, 2009)
• Language: English
• ISBN-10: 0596520123
• ISBN-13: 978-0596520120
• Product Dimensions: 7.1 x 0.7 x 9.2 inches
• Shipping Weight: 1.1 pounds
• Average Customer Review: 4.3 out of 5 stars  See all reviews (24 customer reviews)
• Amazon Best Sellers Rank: #557,313 in Books (See Top 100 in Books)
  • #65 in Books > Computers & Technology > Software > Business > Utilities

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

89 of 95 people found the following review helpful

3.0 out of 5 stars Dives into the weeds and never manages to rise again June 2, 2010

By I Feel Fine

Format:Paperback

This book jumped into the weeds way too fast. Which is good and bad. The label "power user" is appealing and I see the merit in knowing internals. But not with source control. It's a tool. I want to be able to use it productively and quickly and not have to remember MORE THAN two dozen commands. I'm not afraid of branching or merging, but then again, I don't care how these branches and merges are represented as objects on the filesystem.

And that's the problem. This book starts with the assumption that you're interested in the details and will cherish an under-the-hood look. Actually, for me, I really don't care. The details are certain to change. I'm convinced I'll be throwing this book out in a few years because it's outdated. I wouldn't be surprised if Git's hyphenated low level command structure disappears in a few years making this book nearly unusable - these commands are more developer tools than user tools.

With all the negative stuff out of the way, the book does contain a lot of good information. It's easy to read. It hits on a few interesting ideas on managing git. I found no issue following along with the examples - all of them worked fine for me.

45 of 46 people found the following review helpful

3.0 out of 5 stars I just want to get work done... October 27, 2010

By Damien Hull

Format:Paperback|Amazon Verified Purchase

The author really knows his stuff. There's a lot of information on how git works. My problem is that I need to get work done. The book tells you how to create a git repository and add files to it. It doesn't do a good job explaining how to put a file back. That's the information I need.

I wish books like this would give you the basics first. Here's how you create a repository. Here's how you add files. Here's how you put a file back if you change or delete it.

That's my two cents.

13 of 13 people found the following review helpful

5.0 out of 5 stars Great coverage of Git March 19, 2010

By Kevin Rohrbaugh

Format:Paperback|Amazon Verified Purchase

I've been using Git for my side projects for nearly a year now, based primarily on knowledge I scraped together through conference sessions, screen-casts and cheat sheets. This is how a lot of people seem to get started with Git, but at some point it becomes necessary to really understand how it's working and what some of the more advanced commands are for.

This book was exactly the right next step for me, moving me from stumbling around in Git to really understanding it. The author accomplishes this by taking the time to cover Git internals and to build on your knowledge as the book progresses. At first, I resisted all the plumbing explanations, since I doubt I'll be contributing to Git itself, but after a chapter or two it becomes obvious that understanding what Git is doing internally is pretty important to understanding how to interact with it. Additionally, the internals are always explained from a layman's perspective and never get so nuanced that they distract from the topic area being covered.

The book is organized so that you slowly build up knowledge of how Git works, with many topic areas sort of split into a basic and advanced chapter. This was a bit annoying at first, but since the more advanced topics require you to understand other aspects of the tool first, it's necessary. As an example, you need to understand diffs, branching and merges before you can worry about patches, and you need to understand branching and merging before you can worry about remotes.

The book also ends with a decent overview of how to use Git with SVN, which is still pretty important given that a lot of organizations will be relying on SVN for quite some time. Unfortunately, this is one of the few areas that could have used a bit more coverage and seemed to lack the basic and advanced topic setup that worked so well for the rest of the book.

It also doesn't provide much in the way of best practices for employing Git, although I don't see this as a weakness. The closest it comes to recommending a strategy to use it with your team is to kind of sketch out how some very high-profile open source projects work with the tool, which is unlikely to directly apply. Fortunately, there's a lot of content on the Web that covers use cases, branching strategies and best practices, so you won't have trouble finding this information elsewhere. The author doesn't take an opinion on such topics, instead focusing on how to make Git do what you want once you've decided on how you want to use it.

In the end, I recommend this book to anybody who has decided that Git is going to be their DVCS and intends to read the book sequentially, cover to cover. If you're still trying to decide between Mercurial, Bazaar and Git, this is probably a lot more information than you want or require. If you're looking for a quick reference, then the progressive structure may leave you scratching your head when jumping around topic areas.

Once you settle on Git, and want to invest the time to build up the conceptual framework you'll need to succeed with it, this book won't disappoint.