Practical Subversion

By Daniel Berlin and Garrett Rooney

Book Overview

An open source version control project, Subversion is enjoying considerable interest due to its stated intention of resolving longstanding problems found within the aging Concurrent Versioning System (CVS), long the standard solution for millions of projects around the globe. Accordingly, high-profile companies and open source project teams are migrating en masse to Subversion, some of which include all projects maintained by the Apache Software Foundation, Python, Samba, Mono, and Plone. Further, SourceForge.net recently announced Subversion support for its more than 120,000 hosted projects, meaning the more than 1 million members now have the opportunity to begin taking advantage of Subversion's superior management features.

• Format: Paperback
• Language: English
• ISBN: 1590597532
• ISBN13: 9781590597538
• Release Date: November 2006
• Publisher: Apress
• Length: 304 Pages
• Weight: 1.20 lbs.
• Dimensions: 0.8" x 6.9" x 9.5"

Customer Reviews

Not an introductory text, but very deep and accurate

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.

A Step Beyond "Intro"

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

A good companion to Version Control with Subversion

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.

A worthy competitor... and companion.

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

Appendix B has good comparative analysis

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.