I had been using subversion for a few years before I got this book. I was not good at it, I wouldn't even say that I was proficient! This book met me right where I was and helped me to gain confidence and proficiency.
It was a little bit of a pain to have to follow through the examples from the beginning of the book. Nonetheless, I find it to be very useful.

This book is very nice on its propouse. Covers a lot of questions about Version Control and Subversion. Actually nice and objective explanations on the uses and the greater resources that this tool offer us.

The thing that really is missing here, for me, would be examples of "pragmatic" setup of diversified envirioments, I mean, a good evirioment for Web App developing is completely forgotten here. And so for other applications too, such as the development of this self Book. They mentioned as greate note that they used Version Control on this book, actually moved to Subversion, but no topics on Subversioning a Book development.

So, I just think they could expend another hundred pages and go deepier on pratical examples of more sorted applications that Version Controling with Subversion can have.

There's nothing in this book that you can't look up in the svn documentation. However, it is a good introduction and makes the learning curve a little less steep for beginners.

This relatively short book is remarkably easy to read. It lays out a bit of background, gets your started with examples and guides you with a few best practrices. I read the book and worked through most of the examples in about three sittings. I got my first app under subversion the next day.

I've been using CVS for the past few years and have been mostly happy. However, there have been some discussions among developers at my company about moving to Subversion. I was unclear on the differences between CVS and Subversion so I took some time to read Pragmatic Version Control: Using Subversion (The Pragmatic Starter Kit Series)(2nd Edition).

The book begins with some very useful introductory material describing version control in general. I realized while reading that, although I'm a long-time user of CVS, there were some aspects of version control that I was never very clear on. I appreciated these foundational chapters. I also appreciated Mason's sensitivity to the many readers who might have experience with CVS. He frequently points out differences and similarities and explains Subversion functionality in a way CVS users can understand.

After getting the reader up to speed on version control in general, the book moves progressively deeper into the administration and use of Subversion. There is also information on migrating from CVS to Subversion, third party tools, and IDE integration. (I'm in an IBM shop and am looking forward to trying out the Subclipse plugin to integrate Subversion into IBM's Rational Application Developer.) This book will give you everything you need to get up and running quickly. But, it will also give you much more. If you're interested in exploring every nook and cranny of Subversion, you won't be disappointed.

In the end, I discovered that the Subversion project was started by a team of developers with significant CVS experience. They felt that CVS was an aging platform and wanted to build a new, high-performance, version control system that would also fix of all CVS's shortcomings. After reading this book, I can say that I'm hoping to make the move to Subversion soon. The book was very informative and well written. Recommended.

Check out the table of contents and sample chapters on the Pragmatic Publisher website.

i have the first edition of this book, and have found it difficult to learn subversion from it. it's hard to find simple how-to steps for basic tasks, and most of the time i wind up having to look on the internet to find the information. i've had to annotate the book quite a lot, writing simple examples in the margins to make up for the lack of them in the text. for instance, the section on ignoring certain files is only one page long, and doesn't mention anything about ignoring entire directories, or what to do if the directory is already in the repository. things you can eventually figure out on your own, but which are the whole point of buying a book - to do all that work for you, and save you from having to search on the internet!

Mike Mason continues the long tradition of practical, easily readable books in the Pragmatic Programmers series. This book provides an excellent introduction to Subversion for those new to version control systems or Subversion specifically. It does a good job of explaining the rationale behind Subversion's optimistic locking mechanism, provides an overview of basic Subversion commands, and illustrates traditional project and directory structures.

Pragmatic Version Control is easily readable in a few hours and has provided a good reference for basic Subversion operations and reinforcement of CM concepts. The book does not provide, or purport to provide, a detailed reference of complicated Subversion operations. For this purpose, as other reviewers have also noted, the free "Version Control with Subversion" book proves to be much better suited. All-in-all, a solid 4-star read for you intermediate level IT professional, perhaps even a 5-star read if you're new to Subversion and CM.

Quick guide to Subversion, this book took me two sittings to finish reading. I had a subversion server set up and running in no time after the first sitting.

But it doesn't teach you just that, this book also teaches you what a normal project structure looks like. If trunks/branches/tags do not sound familiar to you, you might want to read this book.

If you're already familiar with CVS, though, you might just be fine reading a guide online, instead. Pragmatic Version Control isn't just about how to use the svn command, it's about how to structure your repository, when is it a good idea to branch off a project, why version control is useful, etc. So, if you need a quick guide on how to use Subversion and set up a repository (ie. just for a small school project that probably won't need any branches), you can just read online tutorials.

I've used Subversion to download the source for a couple of open sourced software packages, but that was the extent that I had used it. I decided I wanted to implement revision control on a couple of my projects, so I picked up this book.

The biggest thing I liked about this book was the fact that it wasn't just an installation tutorial like so many tech books seem to be. In addition to installation instructions and configuration, it also gave a thourough walkthrough on how to use Subversion to its full potential. It gave reasons as to why you should place X types of files in Z location, using real-world examples.

Another thing I like is its platform-independance. Many books such as this assume you will be using a Lnix variant. Another may assume you will be using Windows. This book gives commands that will work with both platforms, and gives separate commands when there is a difference. It also goes into using the SVN client on a windows box while connecting to a Linux based server, and vise versa.

The only real complaint I have is it didn't go into enough detail on using svn+ssh to connect to your repository. The book assumes that the repository box is directly attached to the Internet, not behind another firewall or router. This causes some headaches getting th configuration to work, and I feel the book could have resolved this with a few more pages.

If you've been thinking about setting up a Source Code Control system such as Subversion, but have been assuming it is too difficult, pick up this book and you'll find it is a lot simpler than you had expected.

I just started a new software project and decided I wanted to better manage my team and the project. I have been using CVS/CVSup to update my system sources for FreeBSD for years, but never actually setup my own version control system, although I know how important it is.

So after doing a little research, I decided on Subversion. I found the free SVN book "Version Control with Subversion" at
http://svnbook.red-bean.com/, but it's sort of a manual and reference. I was looking for more of a tutorial to give me the gist of how everything works and how it's going to benefit the project. I found "Pragmatic Version Control using Subversion" at
http://www.pragmaticprogrammer.com/titles/svn/. I downloaded the PDF version for $20 and read through it in a day. The Pragmatic book accomplished my goals and prepared me for the free book at red-bean.com. I think having both of these books is all you need to get your team up and running with Subversion.

So, if you add a developer to your project who doesn't know what version control is, give him the Pragmatic book, otherwise just refer to the free book.

One last note regarding my looking for a tutorial on Subversion. When I'm learning a new subject or technology, I like working through hands-on examples. This book met that requirement. It used the same example from start to finish, initially setting up the repository on the local file system to ultimately running it on a remote server.

I gave this book 4/5 stars because it could have easily added 100+ pages of more advanced topics.

I have been using subversion for over a year now. I bought this book after I was some what familiar with svn aka subversion.

I think this book is very good for someone starting off with subversion. The language is pretty good. You can cover this book in just one day!!!

To summarise:
PROS: Simple & Sweet language
Good examples

CONS: Not advanced

I would recommend the free subversion book over this book if you want to learn advanced techniques with subversion.

I liked much the discussions within, but the subjects wider than presented here. But still this is worth the price.

Also nice and small to read, which is helpful.

A good, quick overview of Subversion with decent depth. Focused on things you need to know to be up and running with a professional Subversion environment. Also touches on the major issues of source code control in general and how to deal with them in Subversion.

The value of version control is well known, but getting started can be tough. Many articles begin with the assumption that the reader is already doing version control and is familiar with the related issues. Having read two other books in the pragmatic series, I had high expectations for this book as well as the related product. This book is a good introduction to version control, but more specifically an excellent introduction to Subversion.

The pragmatic programmers come to the rescue with practical advice on how to organize your assets. For me the two best parts of the book are the "Recipes" for using Subversion in the course of application development and the insight on using and managing trunks, branches, and tags. It is much less expensive to gain these valuable insights vicariously (and before your project has a train wreck).

The chapters introduce version control, show how to get started with Subversion, organizing the Repository, using tags and branches, and managing third party code. The appendices cover the installation and administration of Subversion (for both Windows and Linux), migration to Subversion, third-party tools for Subversion, command summary and recipes, and other resources.

Throughout the book, the author uses the command line interface to work with Subversion. While an IDE interface may be used for actual development, seeing the commands executed is a great learning tool. Each command is explained in the context of how it can help solve project-related issues. The explanations are clear and thorough. Illustrations are well used to supplement the text. In the course of the explanations, differences between the CVS and Subversion are noted to ease the transition.

This little book is a good value. It is concise, but rather complete. Beware, after you read it, you may find that Subversion is a better solution than what you currently use for version control.

I have recently been evaluating Subversion (SVN) in order to recommend replacing Borland StarTeam. I will draw some great recommended proceedures from this book. Although using SVN is not difficult in the least, Pragmatic Version Control outlines some best practices that will greatly benefit our implementation.

New to SVN? Need some background on *why* to use SVN? Looking for recommended ways to use SVN? Buy this book.

Followup: We've successfully been using Subversion now for over 6 months. Subversion is quickly becoming the new defacto standard for version control.

At first this book seems unobtrusive next to some other 400+ page books on your bookshelf. However, don't overlook it... This book is really easy to read, has good theory coverage, is brimming with down to earth practical examples and has lots of best practices that one should be using.

The first 150 pages give the reader an in-depth introduction to Subversion and common place version control theory and mechanisms. The last 50 pages cover the appendix dealing with installation, security, migration from dated versioning systems such as CVS, third party tools and last but not least a command summary and set of recipes.

I took a complete day to read the book and try out the examples. Considering the price of the book and the time spent reading it, its return on investment is high. It certainly knocks the socks off some commercial products and training I've seen in the past. Really this is one book I recommend for Architects, Software Engineers and SCM specialists even if you're not using Subversion!

This book really did get me off on the right foot. It provides a helpful perspective that was invaluable to a Subversion beginner. The tone is just right.

However, as I started running into problems, the book fell flat on its face. I couldn't find anything related to my tasks in the index, and there seems to be no coverage of simple concepts like removing directories or groups of files, nor are there any tips and tricks or scripts that might help to maintain my repository. And though there's coverage of a popular Windows GUI client, there's just no help for Mac developers.

I have to give this book three stars. At this price, my hopes were a lot higher.

If I write a review on Amazon, it is usually because a book or product stands out as being much better than average or much worse than average. Mediocrity doesn't inspire me to write.

Anyway, I am totally new to Subversion, having only heard other developers speak highly of it. I got this book in today's mail and I am most of the way through it and feel like I've already gained a very good understanding of Subversion. I had almost no knowledge of it before today, other than knowing it is an open source source/version control product. The book logically introduces the material at a nice, gentle gradient. After a nice introduction, it quickly walks you through a simple example using the command line, which serves to increase your confidence that this is a very robust system, and also familiarizes you, to some degree, with "what's under the hood." You quickly gain an understanding of what it can do for you.

I also downloaded the Tortoise front end and will undoubtedly use that in time, as it looks to be faster than using the command line. But having grown up with command line utilities, I will probably stick with the basic methods first until such time that I am very competent.

The book is easy to read and makes learning SVN enjoyable, confrontable and to some degree fun (which I never expected). This is an excellent introduction to the product and it should help you get up to speed quickly.

This slender text can get you adept with incorporating Subversion into your programming workflow, as a replacement for CVS. Mason explains that though CVS is widely used, that very usage led to a keen appreciation of its limitations. Like not being able to version directories. Which essentially makes them second class compared to files. Yet, in projects of any complexity, the directory tree is a key manifestation of your attack on that complexity. Subversion acknowledges this by making directories versionable.

Naturally, Mason also gives a good general discussion of what versioning is. You may not need this if you are already facile with CVS. But for others, it has merit.

For me, having used a proprietary product, Perforce, Subversion seemed much simpler. Of course, Mason cannot help mentioning that it is open source and free.

Here's a straightforward book with two audiences. First, if you've never actually used version control and you're a bit unsure of why you should and where to start, it provides a gentle introduction to the subject, explaining why this is one of the cornerstones of serious software development. Second, if you are already familiar with version control but thinking of moving to Subversion (particularly if you're already using CVS, the system from which the Subversion designers made their escape) this is the book to get you up and running with a minimum of fuss. The focus is on teaching you how to perform the basic operations that everyone needs to know to use version control efficiently: putting files into a repository, getting them out again, resolving conflicts among multiple developers, handling branches, and so on. You likely won't learn every niggling little detail about Subversion from this book (especially given that it's a program still under active development) but you'll learn plenty enough to get the job done.

After covering the basics of version control and some of the reasons why Subversion is a good choice, Mason shows you how to install things and handle the most basic commands - checking files in and out, and merging changes. He then moves on to larger organizational issues, including tags and branches, multiple repositories, sharing code, and how to handle third-party code. If you've read the earlier Pragmatic Bookshelf title Pragmatic Version Control using CVS you'll find that this book is a port of that one. That is, it includes the same examples, rewritten with Subversion syntax instead of CVS syntax. But it's not always a direct port. The new book is substantially longer than the old one, since Subversion is more flexible, and where Subversion offers a better way to do things than CVS Mason doesn't hesitate to point it out.

You'll also find some coverage here of other topics like using the Windows GUI tool TortoiseSVN, migrating from other systems to Subversion, and setting up Apache to handle Subversion over HTTP. There's a handy listing of commands and recipes at the tail end of the book which provides a fast reference for people who prefer to work at the command line - which, after all, is the most natural environment for Subversion.

Perhaps the best testimonial to the power of Subversion here is that the author convinced the publisher to switch. Pragmatic used to keep book files in a CVS repository. Now they use Subversion. If you're considering making the switch yourself, it's definitely worth picking up a copy of this easy read to help you along the way to success.

When it comes to version control systems, CVS has long been the
workhorse of the Open Source and Free Software movements, but with the release of Subversion it's time to put the old nag to rest; and this book tells you what you need to do it.

Summary
Whether you're new to version control in general or just Subversion itself this book is highly recommended. Clear, concise and crammed full of useful, important and dare I say, pragmatic, advice and information. An excellent book in it's own right and a worthy addition to the Starter Kit Series.