Practical Subversion (Expert's Voice in Open Source) (Paperback)

~ (Author)
Key Phrases: other version control systems, rooneg wheel, rooneg staff, Using the Subversion, Crash Course, Interface Builder (more...)

Editorial Reviews

Product Description

What I especially like about product-oriented books like (<i>Practical Subversion</i>) is when the authors sneak in advice on best practices…gems that make you go, ‘wow,' in a bathtub. (<i>Practical Subversion</i>) introduced me to some new things that I hadn't considered before (tab competion? cool!). (<i>Practical Subversion</i>'s) narrative style means you can actually read it, without being mired in a hodgepodge of footnotes and references.</a></p> </blockquote> <p id="quoteAuthor">&#8212; Rui Carmo, The Tao of Mac</p></div>

<p>This book eases the transition from other version control systems. Aimed toward readers who want and need a crash-course in using Subversion, this informative reference begins with a quick-start introduction, then moves on to advanced topics such as repository administration, Apache integration, third-party tools, migrating revision history, and accessing the Subversion APIs from other programs.</p>

<p>In addition, author Garrett Rooney, a Subversion developer, covers advanced topics not documented in other books. Rooney clearly explains how to integrate Subversion with common development tools and illustrates how to embed Subversion within your own programs. Multiple appendixes compare SVN to other version control systems and offer alternative client applications.</p>

About the Author

Garrett Rooney is a software engineer at FactSet Research Systems, in Stamford, Connecticut, where he works on real-time news feeds. Rooney attended Rensselaer Polytechnic Institute, where he managed to complete 3 years of a mechanical engineering degree before coming to his senses and realizing he wanted to get a job where someone would pay him to play with computers. Since then, Rooney completed a computer science degree at RPI and has spent far too much time working on a wide variety of open source projects, most notably Subversion.

Product Details

• Paperback: 336 pages
• Publisher: Apress; 1 edition (November 15, 2004)
• Language: English
• ISBN-10: 1590592905
• ISBN-13: 978-1590592908
• Product Dimensions: 9.1 x 7 x 1 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 3.4 out of 5 stars  See all reviews (12 customer reviews)
• Amazon.com Sales Rank: #906,547 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

62 of 64 people found the following review helpful:

4.0 out of 5 stars A worthy competitor... and companion., December 23, 2004

By	B. Collins-Sussman (Chicago IL USA) - See all my reviews (REAL NAME)

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

14 of 14 people found the following review helpful:

5.0 out of 5 stars A Step Beyond "Intro", March 26, 2005

By	R. Warner (Jacksonville, FL United States) - See all my reviews (REAL NAME)

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.

7 of 7 people found the following review helpful:

4.0 out of 5 stars A good companion to Version Control with Subversion, January 21, 2005

By	G. Wade Johnson (Houston, Texas) - See all my reviews (REAL NAME)

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.