I picked up this book because, after having worked for a long time with CVS as my only source control system, I moved to Subversion and needed to acquire a deeper knowledge of it (Incidentally, you would be crazy to still use CVS now that Subversion is stable and freely available). And deep does this volume go indeed. It's written largely from the perspective of a repository administrator or a power user wanting to extend the system and develop new applications on top of it, as the long (73 pages) chapter on Subversion APIs demonstrates.

But even if you are a developer wanting to know more about Subversion because your company or favorite Open Source project just standardized on it, you're bound to find a good deal of useful information in it. Just don't think to be able to understand everything is you're totally inexperienced when it comes to source control systems. In this case, I'd suggest "Pragmatic Version Control Using Subversion" as a more accessible alternative.

The introductory chapter (A Crash Course in Subversion) and the Best Practices chapter are very good even for beginners, anyway.

The writing style is clean and linear. Typography is good, apart from the horrible font used for heading and the table of contents.

In conclusion, I don't think you can find anything better, either online or in print, if you really want to make the most out of Subversion, so I give it five stars. The fact that it is not an introductory text should not detract from this judgment but, as always, caveat emptor.

This book covers the in depth stuff of Subversion. If you just want to use Subversion for smaller projects, and small work groups, try Tortoise. It makes everything much simpler.

When Subversion, touted as the replacement for CVS, appeared, many developers undoubtedly downloaded Subversion to check it out. They probably expected it to be as easy to set up and use as CVS; I know I did. While Subversion probably is as easy to use as CVS (and probably easier in many ways), it's definitely more difficult to set up and configure. Most of us developers without ready access to a sysadmin-geek likely stayed with CVS, shelving Subversion as an "I'll get to that later."

Practical Subversion steps up to make "getting to Subversion" possible now. This book eliminates any excuse for forestalling the move to Subversion, whether you currently use CVS, Perforce, SourceSafe, or some other source control tool. This book is all you'll need to migrate to Subversion. Clearly written, it balances prose with actual commands and output, mixing in the occasional screen shot as appropriate. It packs information, and you'll probably want to read it with your fingers on a keyboard, so you can try out the things the book teaches as you read them. It's well edited, too, free from the spelling and grammatical mistakes that plague too many rushed-to-market tech books these days.

If you're looking for a book that gently introduces version control and Subversion to a wide audience, you'll be happier if you look elsewhere. This book seems squarely aimed at tech professionals, and expects competence and understanding of things like compiling, installing, adding entries to inetd, starting and stopping Apache, and finding installed libraries. To get to the meat, I guess, the author decided to skip the hors d'ouvres (to overextend a metaphor). I appreciated this approach, and suspect that most technical professionals will, to. "Lighter" books certainly have their place, but more serious techies appreciate more serious books.

My background: I've worked primarily as a software developer in my career. I am certainly no sysadmin, and found myself stretched in a few places while completing the tasks this book outlines. The penultimate paragraph in this review covers some of my struggles in using this book to get Subversion up and running. People more *nix-fluent probably won't have the same struggles, and maybe those who target Windows will be able to skip the entire issue by using pre-compiled binaries. I get a little nervous, though, anytime I install software on Linux without using apt-get, so I learned a little more on topics beyond just Subversion. YMMV.

As I worked through this book, I installed the Subversion server on a Pentium II 300 running Debian Woody, and installed the client on that same box, as well as on a Windows 2000 box and an iBook running Mac OS X 10.3.8. The server sits behind a hardware firewall, but I configured NAT to expose the server to the Internet, and I verified that I could access repositories from both inside and outside the firewall. I did not install any of the server pieces on a Windows server, but the book covers that as well.

Chapter 1 introduces Subversion and walks the reader through installing and configuring it and the technologies it relies on. It provides a light dusting of what version control is, why Subversion came to be, and what problems it solves. That last discussion probably wouldn't convince the skeptical, if you were thinking to use this book to sell your organization on using source control, but again that's not this book's audience.

Chapter 2 plunges the reader into how to use Subversion from a developer's viewpoint. It explains how to create repositories, how to put files in them, how to work with those files, how to branch, how to create tags, how to merge, how to rename files, and all the other actions developers must do to properly use the tool. Each action is explained and demonstrated with commands. I was able to follow along in my own environment, and everything worked as listed. I'll thumb through this chapter heavily in the months to come, I'm sure.

Chapter 3 aims toward those who must support the operation of Subversion, explaining how to back up and restore the repository, how to lay it out on disk, how to configure hooks (triggers), and how to configure access over the network. The information presented proved sufficient for me to get both WebDAV and Subversion's own server/protocol (svnserve) working with little fuss. This chapter also covers setting up the various users, permissions, and passwords. Sysadmins will rely on this chapter in their day-to-day maintenance of Subversion.

Chapter 4 discusses how to migrate existing source code from other source control tools into Subversion. It specifically covers CVS and Perforce, and also explains Subversion's dump file format that you can use as a reference to write a tool to map your existing repository to a format that Subversion can import. It talks about an intermediary tool, VCP, and a file format, RevML, that can possibly assist to migrate the code base. Finally, it outlines a manual strategy to migrate important revision history if no tool exists and you have no inkling to write one.

Chapter 5 digs deeper into setting up the Apache integration. Focusing on authentication, authorization, and encryption, it explains different ways to lock down your source code. It even explains how to generate a private key and a certificate, so that you can set up SSL on your Apache server. Again, all the commands work as explained, and by following the text I was able to configure my repository to be accessed through basic password authentication, over SSL, using WebDAV.

Most of the information in Chapter 6, Best Practices, applies to any source control tool. Seasoned source control users won't learn much here, except that you can beat your fellow developers who won't commit changes over the head with it. The Subversion-specific information on how to implement some of the best practices, however, is useful, and the inclusion of the chapter is a nice touch.

Chapter 7 explains how to integrate Subversion with various other tools, including Emacs, Ant, Interface Builder, Eclipse, Visual Studio .NET, and the web. It also informs the reader how to install command-line tab completion in both bash and zsh, which makes Subversion command-line usage so much easier. The Mac OS X discussion on how to get Subversion to work with Cocoa's nib "files" is worth the price of the book for Mac users.

I skimmed Chapter 8, which covers the Subversion APIs and how to develop programs that talk to Subversion repositories. I'll certainly get back to this chapter if I ever write Subversion-enabled programs, and the coverage seems both instructive and extensive.

Appendix A includes a Subversion command reference guide, which I'll likely refer to often, and Appendix B maps Subversion's commands to the commands of some other leading version control tools.

I did have some quibbles with this book, probably because of my lightness on sysadmin skills. I struggled to get Subversion to compile with Berkeley DB support, which is essential for the server piece. I followed the book's instructions to the letter, compiling and installing Berkeley DB 4.2 and passing the correct parameters to Subversion's configure script, but configure couldn't find Berkeley DB. Finally, I unearthed the need to put Berkeley DB's lib directory in LD_LIBRARY_PATH. I realize that's in the Berkeley DB docs, but a mention in the book would have saved me quite a bit of time. I haven't gotten cvs2svn to work yet, since I don't have an adequate dbm module installed for Python, and have no clue how to procure nor install one. The book says nothing about that issue nor how to resolve it, and a stock Python install (I compiled and installed 2.4) simply won't work with cvs2svn. Finally, after I'd followed all the instructions to compile, install, and configure Apache and Subversion in the first chapter, I was dismayed to learn halfway through the book that I had to redo it all to get SSL support. It would have been nice to include the necessary SSL information in Chapter 1, so that readers can do the set up only once, even if it's just "do this to enable SSL, which is explained in Chapter 5." I suspect a serious sysadmin wouldn't have tripped over these things, but they got me.

In all, however, this book has walked me through installing and configuring Subversion, and will remain within arm's reach as a continual Subversion reference. For techies who want more than version control and Subversion basics, this is your book.

I have been a CVS user for over a decade and have been looking at Subversion seriously for about a year. I have read Version Control with Subversion, 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. Practical Subversion 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.

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".

"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!

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.