Practical Subversion

Rating:
Summary: Nice coverage, good tips and an easy read
Review: "Practical Subversion" is just that -- a no-fluff-just-stuff guide to using Subversion. It takes the reader from creating his first repository, importing his first project, checking out a working copy, and so on, to administering the repository and integrating with it using a number of programming languages -- briefly but still.

Having said that, and even though it certainly covers a lot of ground, "Practical Subversion" is not a complete reference. The author covers all subjects in a pragmatic manner, covering the common needs well and giving enough hints to help the reader in finding answers for the edge cases.

What I especially like about product-oriented books like this one is when the authors sneak in advice on best practices in using the product, the "tips and tricks" type of gems that make you go "wow" in a bathtub. In addition to learning how to take a backup, I now know how to add auto-completion for Subversion commands in Bash!

Rating:
Summary: A good companion to Version Control with Subversion
Review: I have been a CVS user for over a decade and have been looking at Subversion seriously for about a year. I have read <cite>Version Control with Subversion</cite>, but still felt that there was more that needed to be said. This book covers a lot of the missing information.

Unfortunately, I think this book suffered a bit from trying to do two things at once. Some of the chapters (1, 2, 6, and parts of 3 and 7) were great handbook material. This is the sort of material that I expected from a "Practical" book. The other chapters seemed to aim for being a complete reference on the program. This was only a problem because the two styles were mixed, and changing between them was jarring.

That being said, I think this is a good book that complements the earlier work on Subversion quite well. The reference material on the different server types, programming to the API, and the conversion programs were definitely lacking from the earlier book. <cite>Practical Subversion</cite> does a great job of filling that lack.

The real highlight of the book for me was the chapter on best practices. Over the years, I had to discover most of these the hard way. This chapter should be required reading for any programmer using version control (which should be all of us).

I would definitely recommend the book to anyone using or thinking of using Subversion.

Rating:
Summary: A worthy competitor... and companion.
Review: This review comes with a big disclaimer: I'm probably as biased as one can possibly be. Garrett is my peer. We're both core Subversion developers and I already know all of the information presented in the book. One could argue that my bias is overly positive, because I want this book to sell well and make Subversion more popular and successful. On the other hand, one could argue that I'm negatively biased because I have a competing book on the shelf (written with two other co-authors.) Rather than deny the elephant in the room, though, I've embraced it. For the most part, my review is a comparison between the two books. It's the only viewing lens I have.

It's difficult to write a book about Subversion, not because the software is overly complicated but because version control itself is such a complex and messy topic. There are a bunch of contradictory tensions that are hard to resolve:

* Audience: do you write the book for complete newcomers who know nothing at all about version control? Or do you target experienced users who are migrating from other version control systems?

* Learning styles: some people learn best by theoretical overviews, so-called "top down" learning. They start with the theory then eventually work down to specific examples. Others prefer "bottom up" learning, beginning with detailed tutorials and then extrapolating the large picture from that.

* Descriptive vs. Prescriptive: some users want all options laid out for them, so they can decide how they want to work; others prefer to be told how to work so they can get started right away.

What's fascinating is that for each of these tensions, Garrett has moved in the opposite direction from me and my co-authors.

My own book mainly targets people new to version control, with only occasional "asides" to experienced users. This book, however, definitely targets experienced users. Despite the introduction's claims that inexperienced people should be able to "pick up enough to get started", there's really no clear introduction to version control concepts. My gut feeling is that newbies might find this book a bit unfriendly or confusing. On the other hand, this book does a spectactular job of covering "experienced user" topics that I and my co-authors have been criticized for ignoring. There are whole chapters that provide in-depth comparisons between Subversion and other version control systems such as CVS, Perforce, and Visual SourceSafe. And other chapters cover specific migration strategies from these systems to Subversion. If you're an experienced sysadmin tasked with exploring new options for version control, this is definitely the "meat" you've been looking for.

Another big difference between this book and my own is that it heavily favors the "bottom up" learning style. It's full of detailed examples. Chapter 2 is aptly titled a "crash course" in Subversion, whipping through a whole bunch of topics that my own book takes many chapters to lay out. This certainly isn't meant to be taken as a criticism; many people very much prefer this style of presentation, especially experienced folks interested in getting up to speed as quickly as possible.

And finally, Garrett has focused a great deal of energy on telling readers what they *ought* to do, rather than laying out long descriptions of all things that are possible. This book explains Subversion's flexibility, but at the same time makes good recommendations for using Subversion in real-life situations. Version control doesn't exist in a vacuum. It's almost always part of a larger software development process, and impacts that process heavily. This book does a great job of prescribing policies for committing, branching, merging, testing, and releasing.

The book certainly fulfills the promise of its title: it's truly focused on the practical, rather than the theoretical. It ventures into areas that my co-authors and I have deemed "out of bounds" for our own book, but are still incredibly useful -- topics such as intergration with specific IDEs and editors, web-based repository broswers, and build tools.

Bottom line: I'm really impressed by this book. While both books inevitably contain some overlapping content, the overlap is only partial. And the presentation style and overarching goals of the two books are quite different. I think that version control newbies will have an easier time starting with my own book, but then will ultimately be pining for the information in Garrett's book. And experienced version control administrators will almost certainly be happier starting with Garrett's book first. Either way, it seems that both books belong side-by-side on any bookshelf -- the happy dovetailing of both "bottom-up" and "top-down".


Rating:
Summary: Appendix B has good comparative analysis
Review: Version control of source code is one of these indispensible things when running a software project. Anybody who has ever worked in a commercial project with 2 or more programmers should quickly understand the need.

Well, recently, a new open source program, called Subversion, has arisen to handle version control. Rooney offers a detailed explanation of its usage. Assuming that you have used any other competing system, like CVS, RCS, Perforce or Visual Source Safe, then the text should be readily intelligible. He gives a comprehensive coverage of all that Subversion offers.

But you know what? Aside from what the user has to deal with, you can probably safely disregard certain parts of the book. Because most readers are programmers, and they just want whatever versioning system they use to work. So while Subversion has a better API for third parties to build upon, unless you're one of those third parties, this advantage is moot.

Turn to Appendix B. This is a concise comparative analysis of Subversion vis-a-vis the other versioning programs. If you are still undecided whether to adopt Subversion, the Appendix is the most useful part of the book. For example, Rooney compares Subversion to CVS, which is probably the most common versioning system in use. CVS does not version directories. A glaring defect. Especially because in large projects, the directory tree can encode crucial top level information about the project. Subversion handles directory versioning. But its workflow of "check out, change, update, commit" is basically the same as CVS. So your work patterns don't have to change much.

The biggest other difference between Subversion and CVS is described by the Appendix as how Subversion sends diffs of file changes to its silo. Whereas CVS is more likely to send full files. So less bandwidth and storage. Subversion scales better for large projects.