Home - Languages & Tools

Pro Git

Price: $17.99 ~~$34.99~~

& 2-Day * Free Nationwide Shipping! (* details)

Availability: Usually ship in 24 hours if sold by Amazon.com

Tags: pro git

Product Details

Binding:	Paperback
EAN:	9781430218333
Label:	Apress
Feature:
Publisher:	Apress
Studio:	Apress

Editorial Reviews

Developers need to keep their code from unintended changes. Pro Git is the version control book for all open source developers and quite a few commercial ones, regardless of whether they are hobbyists or professionals. Developed by Linus Torvalds himself, it has taken the open source world by storm and is set to become the standard for open source development.

Customer Reviews

i read through all the other git books to this date and i came to the conclusion that this is the best as far as visual explanations of the git concepts and methodology is concerned. my colleagues had the same "aha" experience as i after reading through this book, as we were all suffering from a not so clear picture of how git actually branches, merges and treats remote repositories.
i can highly recommend it!

I began reading Pro Git, by Scott Chacon, after having already used Git in a
large team-based project. Due to this, I was afraid I would get bored of the
book very easily since I had already learned a decent amount of the material.
This was most assuredly not the case. Chacon has done an excellent job in
writing a book that serves as an excellent beginners guide and a quick reference
at the same time.

The first part of the book is devoted to looking at multiple version control
systems along with a history of version control. Chacon also makes it very
easy to set Git up in a number of environments so that you can get started right
away. The first half of the book is dedicated towards basics of the
system, advanced features, such as rebasing, and setting up a remote server for
git. The next half of the book contains a wealth of knowledge regarding best
practices when using Git, additional tools and configuration options, and
finally, nitty-gritty details on how Git works under the hood.

My biggest complaint would have to be the fact that the material on using Git
remotely is scattered in a couple different parts of the book. This makes it
slightly difficult to find specific information regarding remote work.

Overall, Chacon did an excellent job with Pro Git. After reading this book I
was able to easily fill in the holes in my knowledge and felt significantly more
comfortable maintaining a Git system for personal and team projects.

Scott Chacon is one of the guys behind github -- a hosting site for projects managed by Git distributed version control system. As such, Scott is extremely competent in all things Git, and he wrote a book (or should I say the book) on Git. The book is called Pro Git. I've been using Git for some time now, so I couldn't wait to get my hands on a printed copy of the book. (I'm old-fashioned that way -- I prefer reading paper books.)

Pro Git is published by Apress. On 250 odd pages, Scott manages to bring Git across in a very vivid way. Lots of sample sessions and a huge number of figures make Git come alive and fun to use! (Only at one point while reading the book, did I think: "why is he telling me that?", but it can't have been too bad, because upon writing this, I can't find the place.)

Pro Git starts off easily enough, but it does so at a fast pace, for which I was grateful: you get past the basics on page 45, which means the book gets you set up quickly, so that you can start taking Git for a spin.

Chapter 3 is called "Git Branching", and the thirty pages explain all you ever wanted to know (as well as all you never wanted to know ) about branching. This part is hardcore, but Scott explains this with lots of diagrams, making it easier for us to follow.

One of the best chapters in the book, for me, is called "Git on the server". Scott explains the different methods of setting up Git so as to be able to collaborate.

If you use Git or intend to (and I'd certainly recommend you look at it), I very warmly recommend Scott Chacon's Pro Git: it's the best companion you'll have for Git.

I am a web developer working remotely. I am used to work with Subversion, but wanted to learn Git. The guides and tutorials I found in the web were either too simple or too complex. Until I found the online version of "Pro Git". After being delighted with the first two chapters, and tired of reading on screen, I decided to buy the book. And I am very happy with it!

This book provided the information I wanted, in a perfect rythm - Scott does not waste our time - he provides useful information on every page, and his explanations are extremely well written. Thanks a lot!

Also, the topics and their order are perfect. In chapter 1 and 2, only 45 pages, you learn to use Git, as you may already use Subversion. Chapter 3 is brilliant - it is where Scott explains Git branching - how it works and how you use it. It is also where the power of Git is revealed - and why you should change your version control system to it, if you can.

All the "mistery" terms around Git, like "origin", "master", "push", "pull", "remote", "rebase" are not misterious anymore. You are able to understand their meaning, and not only how to use the commands, but also why, and all the "logic" involved.

Git helps us to do complex things in simple ways - this complexity requires some learning. It is not like software that you can use reading "man" page or a simple tutorial. The "Pro Git" book is a very good resource to get up and running with Git, knowing and understanding very well what you are doing.

I thank the author and recommend this book.

This book succeeds at getting you ready to actually use git in your daily work. It's not a regurgitation of the online docs; it's not a developer's guide written to impress you with the elegance of the implementation. Its main focus is to give the reader practical tips on deploying git in various scenarios. I was familiar with git from having read the O'Reilly book and dabbling a bit, but Pro Git really helped me get over the "activation barrier" and start using it in my own projects.

There are many good tutorials on basic usage of Git but this was the book that taught me the best practices and important workflows which can be employed while using Git. Some parts of the book seem pretty advanced for daily use but the author's grasp of the subject and more important than that his style of explaining most of the difficult concepts proved to be very handy for me. Previously I used CVS and then Subversion for some projects and I started to use Git only a few months ago and now I really ask myself why I didn't read the book as soon as I started to use Git. It would make things much easier for me. Shortly, I sincerely advise this book to any developer who plans to work with Git (it will be especially useful if you're developing an open source project or plan to contribute to a popular one).

I was using the online version of this book for quite some time to get started with Git. However, having a hard copy and reading it front to back gave me a lot of new insights. On screen you just don't read with the same attention. The book is easy to read and it only takes a few hours to go through it.
I wish more technical books would be written like this.

Disclaimer: When I first read this book (almost a year ago), I was a complete beginner with Git. I now use Git on a daily basis and couldn't be a happier programmer.

You're probably asking yourself, "why is this guy writing a review on this book a year after he read it?". Well, I'm writing this review now because I still think about this book daily (and have a copy sitting on the front of my bookshelf). This is one of the best tech books (in general) that I've ever read.

When first reading this book, I had little to no experience with Git. I had heard about it numerous times from friends and colleagues, but never used it in a real sense. What originally motivated me to start learning about it was Github (probably the best website that was ever created for programmers).

After picking up a copy of Chacon's book, and transitioning myself from SVN -> Git, I found myself 'at home' with the Git ideals and methods used to handle version control. After a short period of time, using Git just became second nature, something that I had never experienced in my programming life.

As time has progressed and I've used Git more and more, I've become far more knowledgeable about version control in general, and actually have a far better understanding of source control and practices--something that I was never able to really have 'click' while using SVN or CVS.

Almost a year after my initial reading of 'Pro Git', I now write all software using Git, and couldn't live without it.

In short, buy this book and give Git a chance, you won't regret it. It is not only a life-changing version control system, but 'Pro Git' is an excellent resource to getting started simply, and helps you to really grasp what Git is all about, and why you need to start using it.

This is book easy and intuitive to understand.
I was exposed Git through CIT conference 4 months ago and I want to learn Git.

At the first time, I choose Version Control with Git: Powerful Tools and Techniques for Collaborative Software Development and it is hard to understand the concept of Git and merging/branching of Git.

I thought " Should I read one more time the Version Control with Git or buy another book?".
I choose this book and I am satisfied with my choice.

I realized that how books can be written differently for the same content(git).
If you are new to Git, I strongly recommend this book.

This book is perfect for someone who has a superficial understanding of Git, and wants to learn more.

Starting with basic use cases, logical steps are used to introduce advanced topics such as rebasing and submodules. The last chapter even dives into the contents of the .git directory and the formats of the files found there--including how to manipulate them using low-level commands. There are concise examples that show how use the git command line tool to accomplish each task, and illustrations help understand how each operation changes the state of the repository.

This book isn't the best introduction to version control in general, as the discussion of possible workflows is limited (doing all changes in feature-specific branches isn't the only approach), and it isn't made clear how Git distinguishes itself from other distributed version control systems such as Mercurial or Bazaar.

This is a great read! I have been reading it for the last week or so and I'm almost done with it. I must admit that some of these middle / later chapters are a bit over my head. However, I keep reading anyway and do tend to find nuggets of enlightenment along the way. I don't work on a large team, and will probably only ever use 10% - 20% of the features that Git offers. However, after going through the chapters in this book, I am no longer intimidated by Git via the command line. Scott does a great job of visualizing how the pointers move as I branch, merge, rebase, clone, tag, commit, push, and pull code in and out of repositories. He makes it very easy to understand from the most basic scenarios to some of the more complex scenarios.

I've been an SVN believer for years (via TortoiseSVN), but have seen the light and plan to fully switch to Git after reading this book. Best yet, I was able to easily setup a Git server in a Linux VM by simply following Scott's detailed steps in chapter 4. I'm no longer intimidated by hosting and managing my own Git repo on my own server.

This is a must read for anybody that deals with Git on a day to day basis. I highly recommend it.

The diagrams in this book just shine...

I just recently switched to Git after being a longtime user of other SCM tools. I had no previous knowledge of Git, and purchased this book as a reference to help me understand how Git is different from SVN/CVS/TFS and to help me decide if I was going to switch. I picked two books here on Git (the O'Reilly book being the other) and dove in headfirst.

All of the routine tasks, commands and options are well covered here. Covered topics include all of the required basics, using remote repositories, staging, branching strategies and so on.

I'm a really visual person and I really like diagrams. I was quickly able to understand the key strengths of Git by looking at the included diagrams in a way that just reading some text does not convey.

I've been using this book frequently.

It really bothers me that someone would put in so much effort to write a comprehensive Git book and not include a summary of the Git commands and what each one does. I read this book, like a book - I started at the beginning and read it through. It's a very informative book that details why, when, and how to use many git commands. Now, I want to refer to the book - but the git commands are scattered all over the book. When I want to look up a git command it's likely discussed in multiple places in the book, I have to flip around to dig out the a comprehensive picture of the command.

This book would really be helped by a chapter or appendix that covers *all* of the git commands. I use 'git help' - that's information that should be in this book. I can't be a 'Pro' unless I know all of the commands.

It's a perfect book to learn Git deep and fast.

Takes you just a couple days to read and in my case, I feel now very comfortable with Git thanks to it.

Highly recommended.

Bought the book on recommendation from a friend, who said it was the *only* book you need. He was clearly right.

I'm a, uh, graybeard programmer. Chose git for a recent project, not knowing more than "git clone", and a howto on setting up a repository. Quickly found myself wondering where to turn.

I'm actually only about halfway through the book -- the good stuff is in the first couple of chapters.

I can summarize my experience like this:

1) Get Pro Git (from Amazon). You'll like having it around.
2) Read the first two chapters online while you wait. Experiment.
3) Read the first two chapters again in the hardcopy. They're short.

Thanks, Scott Chacon!

This material is available online, and so the order-one question is whether anyone should buy a paper copy.

I think paper beats screen (to use a RPS sort of phrase), so I purchased a paper copy. I am glad I did. Within an hour, I had come to understand things about git that had escaped me, despite studying a great many websites and manpages. My copy is gradually accumulating marks in the margin, postit notes for important pages, and so forth. Thus, its value (to me, anyway) grows. As is always the case with book, the reader can *find* things in it, because the mind remembers things like "halfway down the left-hand page, five or seven or nine pages past the chapter start". Bookmarks in HTML or PDF are a laughable substitute for this.

I also bought the book to support the author, since he has been so kind as to put the material online for free, and I'd like to buy him a coffee, from the royalty from my purchase.

You'll notice that I've not yet *reviewed* this book. Is it any good? Does he know what he's talking about? Can he explain things? Does he cover the right material, in the right order? Yes, yes, yes, yes, and yes. The book is very nice, gem-like in spots. I'd recommend it to anyone. If git were simpler, or less powerful, or if there were a lot of good existing books, there would be no need for this book. Git is far up there on the importance-and-complexity axis, but down near the origin on the explanation-in-books axis. This book made a big change in the graph.

Go to the Git documentation page at [...]

Click on "Documentation".

Go down to "Books - Pro Git".

Click on "Book".

You are now at [...]

I have been reading here while waiting for my hardcopy print
to become available and ship to me.

The online book is excellent, as is all the other documentation on
Git at the first link listed above.

Excellent clarity on the topics covered. I bought this book on the recommendation of a friend. Though it doesn't cover every git command, it covers plenty to get you going with much more than just the basics. Highly recommended.

I normally don't like reading books about 'tools'. But if you ever want to read one, then this is it. Git is powerful and I have been using it for a while without caring much about what goes on much under.

This is an awesome book and love it. Your time spent will be well worth making your dev workflow. Due to the easiness of Git repo create/edit/branch/destroy, I usually end up using Git for client work and delivering my changes in bulk to whatever old school VCS system client uses.

First of all, I have to admit I am new to GIT, only used it since there was a need in my project. I was used to centralized version control tool such as Clear-case. So when I applied GIT to my new project, I tried to understand GIT with what is available in Clearcase. But it just didn't work. Often, I would get confused. After all, these two are very different. After so much frustration, I checked out this book, I browsed it and immediately liked it. It explains concept quite clear with working examples. I do not know the author by any means, but I have to say, Mr. Scott Chacon did a fantastic job of pass his knowledge to reader like me. That is the reason I would like to give him 5 star. As reader, I hope you will agree with me.

I had never seen Git before installing the software on a Macbook Pro but I was committing my first update within a few painless hours through the Terminal. The visual aids are a great way to get the conceptual aspects of a version control system like Git, and the book shows actual Git commands with terminal responses so you could easily correlate: what you want to do, what commands you need to enter (and why), and what Git should reply back with.

Easy to read, good language and appropriate graphics and code samples at every turn. As far as technical reference books go this is an easy recommendation.

I was a Mercurial fan. I've had to learn how to use Git for work purposes. Initially I hated it but slowly I've grown to love its immense flexibility and power.

Unlike other version control systems, you cannot understand Git without understanding its internals. Once you understand how Git uses trees, commits and blobs you'll begin to understand how the system works. Git can be addictive. What was an arcane set of commands now makes perfect sense to me. A large credit for this understanding must go to Scot Chacon's Pro Git. The book is wonderfully written. It has superb diagrams and is well organized. I've gone through most of the book but keep coming back to it. The book can be read non-linearly or linearly.

This book covers everything from the basics of revision control systems, how git is different, how to set it up, how to use it individually, how to use it as part of a group, how to use it with open source, how to use it within an organization privately, different usage patterns for different styles.. everything. This book is well worth the money I paid, and if you are looking for a great guide to git not matter how small or big your intended usage, this is the way to go.

Excelent book that explains in simple language the more important concepts of git. Coming from other VCS's I had not completely understood git branches until I found this book online.
My only complain with the kindle version are the code snippets being low resolution images.
I have no problem with the book no having a complete reference since git is still a changing program and I feel more comfortable using the included help commands when I need to be reminded of a particular option.
All in all a worthy book.

This book is so good that you feel you have to buy it even though you can get it for free. That's all I need to say.

This is a relatively thin book (250 pages), but after reading it cover to cover, I really feel that I understand everything that I need in order to use Git successfully. Having used many different SCM tools in the past, it took some effort to understand the concepts behind Git, especially as it's a distributed SCM tool that operates differently from many other tools.

This book provides a detailed explanation of the concepts behind Git, using step by step diagrams to explain the workings of the tool. Understanding the internals of Git is very important to using it successfully. This book then extends those concepts and presents them as a series of use cases, making it easy for developers to do the right thing.

First text I've encountered which clearly and at the right pace explained the key Git concepts that are essential for understanding Git and leveraging it's 'killer features'.

For many months I thought I could learn a few commands and pick up the understanding of what was happening in the background on the fly. This was NOT the case and quite a bit of confusion lingered until a couple days ago when I downloaded this to my iPad/Kindle app.

Wish'ed I'd picked this up months ago....but then again if you learn Git with this book for starters maybe it's too easy. I think one is supposed to suffer a bit learning Git ;)

This books cuts down on elaborate explanations of how to work efficiently with git. Great book to hit the ground running on day 5. You will need to practice. Great reference too.

Hi everyone, this book is really if you are new to GIT.

I really liked the graphics and this book is really simple to understand and the examples are really good too.

A must have to learn GIT the right way.

Definitely git (haha) this book if you need to use git. It is much much better than the O'Reilly book.

I'm a professional developer that's used Perforce for going on ten years now. It's a pretty drastic change going to a distributed model. But this book does a very good job of explaining the practical ins and outs. And most of all does a super bang up job of explaining the branching model.

I've been using both CVS and SVN at work, and never had the chance to try Git. I decided to learn about Git, so I looked for a book. I found Pro Git's homepage, with the book fully readable online, in several languages. We don't often have the chance to read free quality books online, but this one is 100% free. After spending some time on the train enjoying the first three chapters of the book, I decided to buy it. It's well worth it. The author did a great job presenting Git's functionalities, and the major differences with other version control systems.

The main chapters on Git basics and branching are very easy to follow. The author explains all the major commands, showing the command line and the execution result. You can read the book without even trying anything (although I would recommend to download Git and try as much as possible). The chapter on distributed workflows is particularly interesting. It shows you how Git is used in a project, depending on the size (and other factors) of the project. Finally, the author presents the major Git tools, explains how to customize Git, how to use it with Subversion (would you do that?), and how Git works internally, which is very instructive.

The book is thin, and easy to read, so anybody can finish it in a short time. If you want to get started with Git, you can pick up this book without hesitation.

I have one minor complaint : the book size is a bit different from other Apress books I have (may depend on the print ?). It breaks the balance of my beloved book shelf :)

I thought this book was a great way to learn and understand Git. I do have experience with older systems (CVS, SVN) but I think the book does a nice job of explaining a software control system overall.

Git does have some philosophical differences with some systems like CVS and SVN and the book does a good job explaining why and the thinking behind the design principals.

I haven't gotten to the most advanced features/uses of git but as the book points out, most users don't need to do so. The project I am working on with over 400 files is up and running nicely.

git is a moving target. It already has a large and complex codebase and is widely deployed in a variety of scenarios: as version control, system administration tool, etc. And it is still evolving, there is new code turning up frequently and new tools being built in conjunction with git. How does one take stock of git and get it to do what you want?

The answer to that question most likely lies in Scott Chacon's book. He covers a lot of practical scenarios and clearly explains how to use git and how to integrate gitinto your environment in a number of ways. Chacon is often on the git mailing list and of course his [...] is hugely popular so he is as much an authority as anyone else.

This book is an indispensable guide to getting git running the way you want it to be in your production environment.

Before acquire this book, I already had a working knowledge about git, but I needed to improve it to assemble a proposal on my work to change our CVS.
Pro Git was the book that helped improve my knowledge about git,since setting up our machines, to create the server environment, as well as the hooks necessaries to our organization.
Scott Chacon covers all the details about using git, since the day-to-day tasks, TO the management of your repository.
The chapter about branching is excellent, it shows all the power of the branching system and strategies to rebase or merge.
A great book.

I needed to learn how to use revision control with multiple LabVIEW programmers. I was annoyed at the limitations of subversion, and I was having a hard time learning git or mercurial from the man pages alone. Somebody mentioned [...] as a resource for learning Git, and so I went there and started reading this book.
I found that I was referring to it a lot, and so I decided to buy the print version.
I love that it's free online, but when I'm working on something, I just don't have the screen space to have an instance of this open all the time, and be able to see this, my command prompt, and my code at the same time.

Again, I encourage buying this, but take a look at the online version if you're curious what's in it.

It's decently written, but reads more like an advertisement than a how-to. After a while, it becomes wearying reading constant comparisons to "other VCSes", all lumped together, when most of the contrasts are being made to systems long outdated and rarely used. The tradeoffs made when using a tool like Git are mostly ignored or glossed over.

All said, this book is preaching to the choir. The true believers who know that Git is forever superior to anything else ever will feel right at, but the rest of us weighing the pros and cons of multiple revision control systems might prefer something a little more technical, a little more objective, and a little less gushy.

Share your thoughts with other customers
Create your own review

Home - Languages & Tools

Pro Git

Product Details

Editorial Reviews

Customer Reviews

Search

Categories