Pragmatic Guide to Git (Pragmatic Programmers)

Well written and the author is correct. The side by side is the best in this situation.I think I can tackle the mysterious and elusive G I T monster. I look at git now, like I used to look at ajax. Everyone talked about how hard it was, etc. but its not. Just read this book and you'll be dangerous with git. I am going to do a "checkout" of my first library (Three20) and see how it goes.Good book, well written. Author has made git accessible to everyone in a very short form. Excellent job. Kudos.

If one is learning to use git, the two things one needs are a clear idea of the data model git uses, and examples relating to both "normal use" and "special case" situations.This book covers the first of these implicitly, by example. This might not be enough, but I can't really comment since I already learned the data model from "Pro Git" (an excellent resource) and "Version Control with Git" (which has decent coverage of the data model).This is primarily a book of examples, and these are excellent: well chosen, clearly and concisely described with useful variations and cross-references. One can read the book, or sections thereof, and quickly gain an understanding of normal usage and work flow. Since it's organized by task, one can also use the table of contents to quickly look up any common functionality and a number of advanced usages. It's the sort of book that becomes a first recourse when one has a question -- it's a faster and more reliable way to get answers about git than online docs or Google, at least until one starts asking more obscure questions.I currently make regular use of the book when I need quick reminders of features I haven't used very much.

This book is pretty much what the title says: a pragmatic guide to understanding and using Git. There is just enough background that you can understand what to do if you have used a VCS before. The 2 page format makes it an excellent reference, and it is also a good book to read straight through. You are likely to want another book to go deeper at some point, but this book will retain a place on your desk as a practical reference.

This book is great for quickly showing you how to use git. As others have said, it does a good job at laying out the basics, without dragging you through a bunch of detail on the inner workings of the tool. For some people that might be nice. I have been using git for quite some time, and I got this book thinking it would help me deepen my understanding and introduce me to things I didn't know before (I had a choice of two books to pick from, and I only knew the title and table of contents...). While there were a few commands in this book that I hadn't seen, the bulk of it was things I have known and used for a long time, and it gives only a shallow explanation of most things. This is not a book for an experienced git user.The book is a handy reference for every day tasks when you're first learning. However, I wonder if a (free) online reference might be just as effective. I suppose that depends on your style. The layout is pretty handy, as has been mentioned in other reviews; it's nice to have a simple description of the task on one side of the page and the commands to do the task on the other side of the page. Some of the font decisions in the book baffle me, though.

Clear, concise. The whole book is "left page: description, right page: examples". One topic per pair of pages. Clearly aimed at people who are new to git (if you already use git, this book will probably be too basic for you).My one complaint is they carry the conciseness a bit too far. For example, when he talks about rebasing, he takes the time to point out that rebasing will be new to users coming from other VC systems, but doesn't bother to explain WHY you might rebase - which I think is something you need to know, even at the most basic level of using rebase. An extra pair of pages would have gone a long way to illuminate rebase.If you want a quick read, that will leave you able to use git, this is your book.If you want to go deeper, the new version of Pro Git comes out later this month. That's 350 considerably more dense pages, that (judging by the first edition) will go much deeper into git concepts. Pro Git is the book to advance your understanding, if you already use git.So, for a quick read & overview: This book.Slower read, more detailed: Pro GitRecommended.

Clearly, not a Version Control Howto, or anything more than a nicely organized array of howtos, e.g., How to clone a repository, How to add a change, How to commit a change, How to share a change, how to fix a change, etc. For desk side reference, this is nearly as good a the internet, and in environments where outside access is not available, this a great.

Every example simply restates basic syntax that can be found anywhere online with only one or two examples. Detail is missing about what actually happens when you type a command. For example "git reset HEAD" vs "git rm --cached" vs "git checkout --" are all described as undoing changes to a commit. More examples and explanation is needed to illustrate how these commands differ with respect to the complete state of any staged commits that may contain other edits, as well as the state of your local edits. The same can be said for fetch, pull, merge, and rebase. The book gives a one page summary of a normal use case for those commands with basic syntax that can be found anywhere online, but the reason I bought this book is that's not sufficient to really understand what's going on and recover from common misuse of those commands when getting tangled up with multiple branches and commits.

Excellent intro to git! Clearly explains the basic concepts and usage. If you read and apply, you'll be an effective git user.