Send a Visa virtual eGift card.
Buy used:
$21.27
Get Fast, Free Shipping with Amazon Prime
FREE delivery Tuesday, November 26 on orders shipped by Amazon over $35
Or Prime members get FREE delivery Sunday, November 24. Order within 4 hrs 34 mins.
Used: Good | Details
Sold by Bank-A-Books
Fulfilled by Amazon
Condition: Used: Good
Comment: 100% Satisfactory Guarantee. Ships directly from Amazon. Book is used but in good condition, may feature minimal highlighting or notes, but pages are crisp and clean with no rips or tears.

Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.

If you're a seller, Fulfillment by Amazon can help you grow your business. Learn more about the program.

Access codes and supplements are not guaranteed with used items.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the authors

Jon Loeliger
Follow
Matthew McCullough
Follow
Something went wrong. Please try your request again later.

Version Control with Git: Powerful tools and techniques for collaborative software development 1st Edition

by Jon Loeliger (Author)
4.4 4.4 out of 5 stars 260 ratings
See all formats and editions
Provides information on using Git to track, merge, and manage software projects.
Previous slide of product details
  1. ISBN-10
    0596520123
  2. ISBN-13
    978-0596520120
  3. Edition
    1st
  4. Publisher
    O'Reilly Media
  5. Publication date
    June 1, 2009
  6. Language
    English
  7. Dimensions
    7 x 0.9 x 9.19 inches
  8. Print length
    310 pages
  9. See all details
Next slide of product details
Amazon First Reads | Editors' picks at exclusive prices

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

  • Publisher ‏ : ‎ O'Reilly Media; 1st edition (June 1, 2009)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 310 pages
  • ISBN-10 ‏ : ‎ 0596520123
  • ISBN-13 ‏ : ‎ 978-0596520120
  • Item Weight ‏ : ‎ 15.7 ounces
  • Dimensions ‏ : ‎ 7 x 0.9 x 9.19 inches
  • Customer Reviews:
    4.4 4.4 out of 5 stars 260 ratings

About the authors

Follow authors to get new release updates, plus improved recommendations.
Previous page
  1. Jon Loeliger

    Jon Loeliger

    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    Discover more of the author’s books, see similar authors, read book recommendations and more.

    See more on the author's page
  2. Matthew McCullough

    Matthew McCullough

    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    Matthew McCullough is an energetic 14 year veteran of enterprise software development, open source education, vice president of Training at GitHub, and co-founder of Ambient Ideas, LLC, a Denver consultancy. Matthew currently is a member of the JCP, reviewer for technology publishers including O'Reilly, author of the Presentation Patterns & Anti-Patterns book, multi-year speaker on the No Fluff Just Stuff tour, author of the DZone Maven, Git & Google App Engine RefCards. He channels his teaching energy through activities as President of the Denver Open Source Users Group.

    Matthew loves technology, but has always had a parallel passion for teaching technical topics. He's struggled with the same challenges that any presenter would -- assembly of slides, hardware meltdowns, venue catastrophes, audience attentiveness, and acceptance to international venues he never thought would actually say yes. Matthew is excited to share these learning experiences and concrete solutions to the challenges in both story and recipe form in this book.

    Matthew resides in Denver with his beautiful wife and daughter, who are active in nearly every outdoor activity Colorado offers. He writes frequently on software and presenting.

    See more on the author's page
Next page

Customer reviews

4.4 out of 5 stars
260 global ratings

Customers say

Customers find the book helpful in explaining and demonstrating Git concepts and behavior. They appreciate the excellent coverage of topics and concepts, as well as the high number of working examples. Opinions differ on readability, with some finding it concise and easy to understand, while others say it's frustrating and a mess.

AI-generated from the text of customer reviews

Select to learn more
UnderstandingContent depthReadabilityOrganization
31 customers mention "Understanding"28 positive3 negative

Customers find the book helpful in explaining what's happening to revisions in the repository. They say it provides a good overview and sufficient detail to feel confident as a user. Readers also mention the book is a good reference book for work, with a practical approach towards the concepts. Additionally, they mention it raises their understanding of the process.

"...n't use the command line or are afraid to, this book will offer guidance and reassurance that you're looking at and doing the right thing...." Read more

"Solid discussion of Git for someone like me who has primarily been using CVS and SVN (Subversion) throughout their career, and has since started..." Read more

"...concepts and architecture in great detail, and provide a comprehensive understanding of why and how git works the way it does...." Read more

"...While I was very impressed with the book and the author's obvious familiarity and knowledge about git, I felt that the chapters were sometimes..." Read more

11 customers mention "Content depth"11 positive0 negative

Customers find the book's content depth excellent. They say it's a great resource with an example that runs throughout. Readers also appreciate the high number of working examples. In addition, they say the depth of coverage is appropriate, with no essentials left glazed over.

"...(which explain Git objects and commit graphs) and the high number of working examples (of which I recently executed about 90% or so)...." Read more

"...while they are contrived for simplicity, they are also representative of real life usage." Read more

"...The depth of coverage is appropriate, with no essentials left glazed over and no unnecessary exhaustive coverage of extraneous edge-case sub..." Read more

"...and have some idea of what add, commit, push, and pull mean, this is a great resource...." Read more

18 customers mention "Readability"10 positive8 negative

Customers have mixed opinions about the readability of the book. Some mention it's concise, well-written, and easy to understand. However, others say it's frustrating, a mess, and worthless as a reference. They also mention the tutorial-like material is scanty.

"...Working through this book, I especially appreciated the diagrams (which explain Git objects and commit graphs) and the high number of working..." Read more

"...if you want to jump in to using git right away, as the tutorial like material is scanty...." Read more

"...The book is okay, the author is succinct and goes direct to the point, the language is clear (important for non native English speakers), the book..." Read more

"Though more comprehensive than Scott Chacon's Pro Git, this book is a mess. It fails both as a reference and as a tutorial...." Read more

4 customers mention "Organization"0 positive4 negative

Customers find the book's organization not as well organized as they would like. They say the topics aren't presented in ideal order and the chapters are sometimes ordered strangely.

"...I give it four stars for content, and dock it a star for its abysmal organization...." Read more

"...and knowledge about git, I felt that the chapters were sometimes ordered a little strangely...." Read more

"...was intended as a tutorial but for that I found that topics were not presented in ideal order and the most common command usages were not always..." Read more

"...The problems are:- It lacks a strong organization...." Read more

Top reviews from the United States

battlewithin
5.0 out of 5 stars Dated but holds value
Reviewed in the United States on August 16, 2022
Verified Purchase
It's obvious from the start that this book is quite old. It regularly goes on about some major changes that took place around version 1.6 of Git. We're out on version 2.37 right now, so all of that is basically ancient history.

Aside from that, it covers all you need to know and some you don't. If you don't use the command line or are afraid to, this book will offer guidance and reassurance that you're looking at and doing the right thing.

I wouldn't consider myself any sort of "power user" when it comes to Git; I'm happy to let IntelliJ do a lot of the heavy lifting. But that being said, there are things IntelliJ can't do. Likely many more things I don't or didn't know about until reading this book.

I'm not saying that Git is by any means poorly documented. In fact, it's quite the opposite. If you run `man git` from a Terminal window, you won't make it passed the Description before encountering a reference to more documentation (i.e., `gittutorial`). Now, what I will say is that man pages are also not the easiest to get through... So this book fills the gap. You can always go back to the source, but sometimes it's nice to have a more user-friendly option for quick reference. This book is that.
2 people found this helpful
Helpful
 Report
Kevin Rohrbaugh
5.0 out of 5 stars Great coverage of Git
Reviewed in the United States on March 20, 2010
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.
12 people found this helpful
Helpful
 Report
EG
4.0 out of 5 stars Not a "train wreck"
Reviewed in the United States on May 8, 2015
Verified Purchase
Solid discussion of Git for someone like me who has primarily been using CVS and SVN (Subversion) throughout their career, and has since started using Git. While I do not view this book as the "train wreck" that the top reviewer here describes, be aware that if you are completely new to version control systems (VCS) you will likely want to look elsewhere (at least for introductory explanations), because the authors jump right into Git usage without first providing much VCS background information.

After a cursory Git introduction, the authors provide what I consider the core of the text (the first 14 chapters of 21), covering installation, how to get started, basic Git concepts, file management, the Git index, commits, branches, diffs, merges, altering commits, the stash, the reflog, remote repositories, repository management, and patches. After this core, the discussion turns to hooks, combining projects, submodule best practices, using Git with SVN repositories, advanced manipulations, tips/tricks/techniques, and use of GitHub (although I decided to skip a couple of these latter chapters, such as the one on hooks, because I do not plan to use this feature in the near future).

Working through this book, I especially appreciated the diagrams (which explain Git objects and commit graphs) and the high number of working examples (of which I recently executed about 90% or so). The diagrams which explain branching and merging are the types of diagrams typical colleagues and I white board with each other to explain a given project state, helping enable both understanding of the material as well as providing future reference for visual depiction.

One of the reasons I decided to go with this book to get more familiar with Git, other than the fact that there are not many Git texts of which to choose in the marketplace, is because it was published relatively recently relative to when I purchased it about a year ago. Unfortunately, a potentially better book called "Pro Git (Second Edition)" that other reviewers have mentioned has since been published, something that happens when a book is not read soon after purchase.

Be aware that while almost every single example that I executed over the course of working through this book ran flawlessly (somewhat of a rarity with technology texts), I did notice on a few occasions that the command line output from a handful of commands was slightly different than what was represented in the material, and I attribute this to a lack of alignment between the Git version that the authors used (1.7.9) and what I used (2.1.4), downloaded as part of Cygwin. However, this aspect did not distract from the material presented by Loeliger and McCullough.

Although the chapter on installation (Chapter 2) does briefly mention the Git version that the authors used, the remainder of the book really does not address this topic apart from a few isolated instances. For example, the chapter on remote repositories (Chapter 12) mentions that differing versions will display a remote-tracking branch differently. When executing another example in the same chapter, I came across a warning that gets displayed when pushing to the depot because the implicit value of "push.default" was changed in Git 2.0 from "matching" to "simple". And although minor, an attempt to clone the 1.5.x branch of SVN referenced in the chapter on using Git with SVN repositories resulted in a "repository moved temporarily" message (the most recent stable version of SVN is currently 1.8.13).

In general, however, this book provides a solid discussion of Git, and these are all but minor annoyances. A review of Git itself is not the purpose of a Git book review, but if you are at a point where you have solely heard about Git from colleagues who recommend that Git should be used because "it's cool" or remark that "all you really need to know are like three commands, don't worry about the other stuff" (I have actually heard developers make these types of comments), diving into Git with regard to what is happening under the covers is arguably the right way to go, and this book can help.
16 people found this helpful
Helpful
 Report

Top reviews from other countries

Translate all reviews to English
Dr Ron Catterall
4.0 out of 5 stars GIT
Reviewed in Mexico on December 22, 2019
Verified Purchase
good book, o'reily quality
Report
jayaich
5.0 out of 5 stars Very good book - useful and in-depth
Reviewed in the United Kingdom on March 15, 2018
Verified Purchase
I needed something more than just googling about git as we were going to be using git more and more at work. This book seemed ideal. As others have said it's not a pocket guide though. It does cover some areas that I may well never use, but it also covers the basics. And that's good. I have used it as a reference, and on occasion had to go back and re-read certain areas in which I needed to understand something a bit more deeply.
Overall I found it easy enough to read, in depth but you don't have to read everything if you don't want to, and good as a reference book. It has certainly helped me with using git (from the command-line) at work.
Report
Hayato
5.0 out of 5 stars Good book !!
Reviewed in Japan on September 12, 2018
Verified Purchase
Easy to understand and follow.
Good for those who want to star learning about git.
Report
Bartolomucci Fabrizio
5.0 out of 5 stars Really beautiful
Reviewed in Italy on May 28, 2014
Verified Purchase
Very chaming and elegant, and also belle built to overcome normal life events. As it is with most things coming from Italy.
Report
Felix J. Ogris
5.0 out of 5 stars top
Reviewed in Germany on January 26, 2014
Verified Purchase
Lesenwertes Handbuch zu git. Der Autor geht nicht nur auf die alltäglichen Befehle ein, sondern erläutert auch, wie git unter der Motorhaube arbeitet, was den einen oder anderen ungewohnten Arbeitsschritt verständlich macht.
Report