Version Control with Git: Powerful Tools and Techniques for Collaborative Software Development |  | Author: Jon Loeliger
Publisher: O'Reilly Media
Category: Book
List Price: $34.99
Buy New: $18.99
as of 9/5/2010 09:02 CDT details
You Save: $16.00 (46%)
New (31) Used (11) from $17.00
Seller: ztbbks
Rating:  13 reviews
Sales Rank: 51,115
Media: Paperback
Edition: 1
Pages: 336
Number Of Items: 1
Shipping Weight (lbs): 1.1
Dimensions (in): 9.4 x 7.1 x 0.9
ISBN: 0596520123
Dewey Decimal Number: 005.1
EAN: 9780596520120
ASIN: 0596520123
Publication Date: May 27, 2009
Availability: Usually ships in 1-2 business days
| |
| Features:
| • | ISBN13: 9780596520120 | | • | Condition: New | | • | Notes: BUY WITH CONFIDENCE, Over one million books sold! 98% Positive feedback. Compare our books, prices and service to the competition. 100% Satisfaction Guaranteed |
|
| Also Available In:
|
| Similar Items:
| |
| Editorial Reviews:
Product Description
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.
|
| Customer Reviews:
Showing reviews 1-5 of 13
Excellent for all experience levels September 9, 2009
orangekay (San Francisco, CA United States)
17 out of 18 found this review helpful
Out of the current crop of distributed version control systems, Git is by far my least favorite. Unfortunately for me, out of the current crop of distributed version control systems, Git is the only one that I don't have to spend an hour chasing bizarre, nonsensical uncaught Python exceptions every time I upgrade, so it's the one I've been stuck gravitating toward.
Luckily, just about anything I don't like about Git can be customized out of existence, but up until now, figuring out how to go about doing this the right way has always been something of a guessing game. This book starts you off on the right foot and gives you the best practices you'll need to adopt in order to not make a fool of yourself, which is really all you can ever hope for.
Highly recommended to anyone who needs or wants to work with Git, even if you already know what you're doing.
well written; easy to understand July 14, 2009
Richard Morin (San Bruno, CA, USA)
17 out of 20 found this review helpful
I found this book to be very well and carefully written. As a technical writer and editor, I'm extremely picky about copy errors, language usage, etc. I was pleasantly surprised to find almost no problems of this sort.
I also found the book remarkably easy to understand. Given the complex and esoteric nature of the topic matter, this is quite an accomplishment! In summary, I would recommend this book highly as an introduction and reference to Git.
GIT ME!!! August 20, 2009
John R. Vacca (Pomeroy, Ohio)
9 out of 10 found this review helpful
Do you want to gain insight into some of Git's internal design and be able to master some of its more powerful techniques? If you do, then this book is for you! Author Jon Loeliger, has done an outstanding job of writing a book that shows you how you can learn enough about basic Git operations to be productive in a short while.
Loeliger, begins by showing you how to install Git on Linux and Microsoft Windows and within Cygwin. Next, the author explores why and where Git differs by examining the key components of its architecture and some important concepts. Then, he explains how to manage the index and your corpus of files. The author continues by showing you how to select, create, view, and remove branches. Next, he covers some of the basics of git diff and some of its special capabilities. Then, he shows you how to combine two or more different lines of development. The author continues by showing you examples and techniques to share, track, and obtain data across multiple repositories. Next, he presents two approaches to managing and publishing repositories for cooperative development. Then, the author explains when you might want to use patches and shows you how to generate, send, and apply a patch. He continues by discussing why developers create submodules and how Git attempts to deal with them. Finally, the author shows you how to use Git when the rest of your team employs a Subversion.
This most excellent book shows you why Git is a powerful, flexible, and low-overhead version control tool that makes collaborative development a pleasure. More importantly, if you read this book cover to cover, you'll discover why Git has proven valuable to a wide range of projects.
Best book available on git, almost perfect January 1, 2010
E. Paulson (Madison, WI)
3 out of 3 found this review helpful
This is absolutely the best book on git available, and even if you've used git before you'll learn something from it.
The first five chapters are perfect, and do an amazing job of explaining what the heck git is doing.
If there's anything wrong with the book, it starts to show up in chapter 6, which is where new concepts are referenced many chapters before they're explained (for example, all the sudden remote tracking branches show up 5 chapters before they're actually explained). Sometime's there's just no way around this - it's tough to untie all of the knots of git.
Expect to read chapters 6 (commits) and chapter 9 (merges) twice - ideally after you've read the whole book and have actually used git to manage a project with branches.
There's plenty to tighten up for a second edition, but it still gets five stars.
Great coverage of Git March 20, 2010
Kevin Rohrbaugh (Loveland, OH USA)
3 out of 3 found this review helpful
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.
Showing reviews 1-5 of 13
|
|
|
