Buy New
-45%
$24.89$24.89
$3.99 delivery Monday, May 4
Advertisement
Advertisement
Ships from: GreenIceMedia Sold by: GreenIceMedia
Used - Very Good
$6.52$6.52
FREE delivery April 30 - May 4
Advertisement
Advertisement
Ships from: GREENWORLD BOOKS Sold by: GREENWORLD BOOKS
Sorry, there was a problem.
There was an error retrieving your Wish Lists. Please try again.Sorry, there was a problem.
List unavailable.
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.
Follow the authors
OK
Version Control with Git: Powerful tools and techniques for collaborative software development 2nd Edition
Purchase options and add-ons
Get up to speed on Git for tracking, branching, merging, and managing code revisions. Through a series of step-by-step tutorials, this practical guide takes you quickly from Git fundamentals to advanced techniques, and provides friendly yet rigorous advice for navigating the many functions of this open source version control system.
This thoroughly revised edition also includes tips for manipulating trees, extended coverage of the reflog and stash, and a complete introduction to the GitHub repository. Git lets you manage code development in a virtually endless variety of ways, once you understand how to harness the systemâ??s flexibility. This book shows you how.
- Learn how to use Git for several real-world development scenarios
- Gain insight into Gitâ??s common-use cases, initial tasks, and basic functions
- Use the system for both centralized and distributed version control
- Learn how to manage merges, conflicts, patches, and diffs
- Apply advanced techniques such as rebasing, hooks, and ways to handle submodules
- Interact with Subversion (SVN) repositoriesâ??including SVN to Git conversions
- Navigate, use, and contribute to open source projects though GitHub
- ISBN-101449316387
- ISBN-13978-1449316389
- Edition2nd
- PublisherO'Reilly Media
- Publication dateSeptember 25, 2012
- LanguageEnglish
- Dimensions7 x 1.25 x 9.19 inches
- Print length452 pages
There is a newer edition of this item:
$43.23
(43)
Only 8 left in stock (more on the way).
Frequently bought together

Customers who viewed this item also viewed
Version Control with Git: Powerful Tools and Techniques for Collaborative Software DevelopmentPaperbackFREE Shipping by AmazonGet it as soon as Tuesday, Apr 28Only 8 left in stock (more on the way).
Git Pocket Guide: A Working IntroductionPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Tuesday, Apr 28Only 14 left in stock (more on the way).
Learning Git: A Hands-On and Visual Guide to the Basics of GitPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Tuesday, Apr 28Only 18 left in stock (more on the way).
Ultimate Git and GitHub for Modern Software Development: Unlock the Power of Git and GitHub Version Control and Collaborative Coding to Seamlessly ... Software Projects (English Edition)PaperbackFREE Shipping by AmazonGet it as soon as Tuesday, Apr 28
Pro GitPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Monday, May 4Usually ships within 3 to 5 days
Git for Teams: A User-Centered Approach to Creating Efficient Workflows in GitEmma Jane Hogbin WestbyPaperbackFREE Shipping by AmazonGet it as soon as Tuesday, Apr 28Only 3 left in stock (more on the way).
Customers also bought or read
- Version Control with Git: Powerful Tools and Techniques for Collaborative Software Development
Paperback$43.23$43.23FREE delivery Tue, Apr 28 - Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming#1 Best SellerIntroductory & Beginning Programming
Paperback$27.53$27.53Delivery Tue, Apr 28 - Learning Git: A Hands-On and Visual Guide to the Basics of Git
Paperback$34.92$34.92Delivery Tue, Apr 28
From the Publisher
Git Pocket Guide
|
Version Control with Git
|
Git for Teams
|
Building Tools with GitHub
|
|
|---|---|---|---|---|
|
Add to Cart
|
Add to Cart
|
Add to Cart
|
Add to Cart
|
|
| Customer Reviews |
4.5 out of 5 stars 295
|
4.4 out of 5 stars 267
|
4.1 out of 5 stars 39
|
4.8 out of 5 stars 6
|
| Price | $13.99$13.99 | $24.89$24.89 | $38.68$38.68 | $13.60$13.60 |
| Click on these related titles: | A Working Introduction | Powerful tools and techniques for collaborative software development | Powerful tools and techniques for collaborative software development | Customize Your Workflow |
Editorial Reviews
Book Description
About the Author
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.
Matthew McCullough, Vice President of Training for GitHub.com, is an energetic 15-year veteran of enterprise software development, world-traveling open source educator, and co-founder of a US consultancy. All these activities provide him avenues of sharing success stories of leveraging Git and GitHub. Matthew is a contributing author to the Gradle and Jenkins O'Reilly books, as well as the creator of the Git Master Class series for O'Reilly. Matthew also regularly speaks on the No Fluff Just Stuff Java symposium series. He is the author of the DZone Git RefCard, and president of the Denver Open Source Users Group.
Product details
- Publisher : O'Reilly Media
- Publication date : September 25, 2012
- Edition : 2nd
- Language : English
- Print length : 452 pages
- ISBN-10 : 1449316387
- ISBN-13 : 978-1449316389
- Item Weight : 1.54 pounds
- Dimensions : 7 x 1.25 x 9.19 inches
- Best Sellers Rank: #2,186,406 in Books (See Top 100 in Books)
- #97 in Software Utilities
- #1,088 in Microsoft Programming (Books)
- #2,427 in Software Development (Books)
- Customer Reviews:
About the authors

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

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.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Generated from the text of customer reviewsSelect to learn more
Top reviews from the United States
There was a problem filtering reviews. Please reload the page.
- Reviewed in the United States on March 20, 2010I'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.
- Reviewed in the United States on August 16, 2022Format: PaperbackVerified PurchaseIt'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.
- Reviewed in the United States on October 31, 2011This book gets you down and dirty, concisely, and in an easy-to understand manner. It starts with the no assumption of knowledge for git whatsoever, and quickly takes you headfirst into the internals and mechanics. This book is wonderful to get a solid understanding of how git works and I'd give it a good recommendation for anyone needing revision control for Important Files (thesis papers, code, hitlists).
That being said, if you just want to maintain your dotfiles offsite without too much hassle, this book may not be for you: the regular usage of git is not covered directly. Rather, it builds up from the plumbings and inner workings of git to (eventually) take you to the point of regular usage. If you have the time for it, I'd recommend it, but the knowledge you're looking for might only be a few Google searches away, and worded more directly.
I'm docking one star for a few typos present in commands that the user is supposed to execute, which may leave beginners confused as to why it's not working like it's supposed to. Given the critical location of the typos, I'm left wondering if typos were the only oversight in the editorial process.
- Reviewed in the United States on January 24, 2014This is a great book for understanding the internals of Git. The book is not necessarily a good one to start with if you want to jump in to using git right away, as the tutorial like material is scanty. It spends less than 15 pages (Kindle edition) to provide a basic usage scenario, then jumps into the core concepts. This might be frustrating for someone new to git, who is looking to get a quick overview of how to use the system.
However, for anyone with some basic prior experience of git, this is a treasure trove, as the authors take great care to explain the underlying concepts and architecture in great detail, and provide a comprehensive understanding of why and how git works the way it does. This is invaluable, given the relatively dense nature of git's own documentation (see the man or help pages, and you will know what I mean), and the complexity that necessarily comes from such a flexible piece of software.
In a nutshell, a very good buy if you already know git. For introductory material, look elsewhere.
Top reviews from other countries
HayatoReviewed in Japan on September 12, 20185.0 out of 5 stars Good book !!
Format: PaperbackVerified PurchaseEasy to understand and follow.
Good for those who want to star learning about git.
-
Felix J. OgrisReviewed in Germany on January 26, 20145.0 out of 5 stars top
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.
peter4361Reviewed in the United Kingdom on October 14, 20205.0 out of 5 stars Best git learning resource
Format: PaperbackVerified PurchaseThis is simply the best git learning resource which I've yet come across. So many git books and howtos just work from a top-down standpoint: "if you want to do so-and-so, then run this git command" - which works for a while, until something breaks, and the user doesn't know how to fix it. This book takes a solidly bottom-up approach - starting with the structures that git uses, and the low-level commands which can be used to examine and understand them. Only when this foundation has been put in place do the authors start to look at the main git commands and operations. The text is well-written and readable, and there are numerous examples - which work! One of the best books from O'Reilly (which is saying a lot).
Dr Ron CatterallReviewed in Mexico on December 22, 20194.0 out of 5 stars GIT
Format: PaperbackVerified Purchasegood book, o'reily quality
Bartolomucci FabrizioReviewed in Italy on May 28, 20145.0 out of 5 stars Really beautiful
Very chaming and elegant, and also belle built to overcome normal life events. As it is with most things coming from Italy.









![Computer Networking Bible: [3 in 1] The Complete Crash Course to Effectively Design, Implement and Manage Networks. Including Sections on Security, Performance and Scalability](https://m.media-amazon.com/images/I/41H4YJnxKgL._AC_SR100,100_QL65_.jpg)

