Assuming that I'm starting a new web project at home using Visual Studio, which version control system, viz. Git or Subversion will be better to use? Which one will have the least setup complexity?
Since this is for your own personal playing around, my question is simple: Do you know Subversion or Git already?
If you know SVN - use Git.
If you know Git - use SVN.
If you don't know either - use SVN. It's a better introduction.
I'd go with Git. It's not that bad getting up to speed on the basics (there are now a ton of good resources, including learn.github.com) and it'll pay off in spades. And I've been using it on Vista with no probs.
Subversion is far more Windows-friendly in my experience and also more immediately useful for the solo developer.
Another possibility is Perforce, which is slightly less Windows-friendly, but full featured and fairly easy to use, not to mention free for up to two users.
Git is a distributed source control setup and as you are the only user I can't imagine that you would benefit much from its features. Subversion is (in my opinion) easier to set up so I would recommend you go with it.
If you are working alone and want some kind of version control easy to use, then use Subversion.It works great on Windows, setting up the repository is one right click in an empty with Tortoise SVN. Ankh SVN provides a very good integration with Visual Studio - almost on par with TFS provided you use VS 2005 or more recent.
On the other hand, Git is much more promising than SVN. I'll check it during this year, but third party tools are not on par yet.
I'd go with Mercurial instead. It's supposed to be similar to Git (which I never could get running because of the Windows issue) and is really easy to setup in Windows & very nice for "personal" version control systems.
Which one you decide to use depends a lot on what your needs are now and going forward. Git has a very nice community built a round it with GitHub which is great for sharing code and projects. SVN is pretty simple to setup and get going, but in large teams Git has it beat hands down with it's branching and merging. This is ideal in cases where you have multiple people working on the same project, either in an office setting or an OSS sense where the team is spread out.
If all you need is something quick and simple to setup and get going so you can start your project, SVN should be fine. SVN is also integrated into many editors and IDE's as well as many bug tracking and continuous integration systems.
If you plan on having a team, or already do, Git is worth looking at for its branching and merging setup. Git however, due largely to still being kind of young, doesn't have nearly as much support available
If you want Visual Studio integration there is no question. Only Subversion has Visual Studio integrations (AnkhSVN, VisualSVN and several scripts that allow access to TortoiseSVN).
One of the most important reasons that Subversion has such a large amount of tools written for it is that it was designed as a stable library for use by multiple clients.
It's unlikely that Git gets the same level of integration in Visual Studio before git support is available as some kind of reusable library. (There are plans for a libgit2 that could make this a reality).
Let's my ride-in on your question and ask:
Does Git work on Windows?
Does it have something that's equivalent to Tortoise? (otherwise I don't see how it could compete with SVN in terms of ease-of-use)
On a side note: If it's really a one man home project, you don't really need any source control tool. Just put your project in a DropBox folder and you're done (auto-commits, infinite revisions, undelete).
Unless you really think you're going to need tags and branches and stuff. But for personal home projects... do ya?
You can make your own opinion after reading this : http://whygitisbetterthanx.com
Git................................(these dots are there because SO wont accept a 3 lettered answered).
A great answer to this question was recenting written about by Jack Repenning here:
If you have compelling requirements for a single, certain, master copy of your work, use Subversion. You can do this with Git, so long as there are no slip-ups. But you can’t do anything else with Subversion (slip-ups or no), and “compelling requirements” like Sarbanes-Oxley are happier with guarantees than possibilities.
If you plan to maintain parallel, largely shared but permanently somewhat different lines of the same product, use Git. One common example: perhaps you have a large product that you customize for each customer. The customizations are permanent, and generally not shared among code lines, but most of the code is common to all. Git was designed for just this case (in Git terms, local customizations to the common core, and occasional feature or bug-fix contributions back up-tree)
Neither of those? Take your pick, you should be fine with either tool.*
Full Blog Post here: http://blog.codesion.com/post/15692788883/subversion-or-git-decisions-decisions
With SVN you will have to set up a server, create a repository there, check out the (empty) repository, add your files, and then commit.
With Git, all you need is git init in your project's root directory. Then you can add and commit files as you see fit.
There's not really any idea in setting up a Subversion server, since you're the only one working on the source. Contrary to what many people think, solo projects is a perfect match for distributed version control tools. It's also very easy to grow your project later on.
In my experience, Subversion is easier to "grok", but Git is faster and easier to engage in software development best practices. As a former CVS user, Subversion made immediate sense to me when I started using it. Git took some study and I still have to refer to the manual from time to time, but I love how easy it is to branch and merge code when I've got to maintain a release process.
If you are already familiar with CVS and just need something to keep your history and diffs, Subversion will be easier to get started with. If you are new to version control, the tide is shifting toward DVCS in general and Git in particular, so you may get more mileage out of that in general.
I do recommend you look at a hosted provider so you don't have to worry about setting up a Subversion server or so you can have a backup location for your Git data. You can Google for "subversion hosting" or "git hosting" to see the premier providers in the space.
If you plan to take your project along on an USB stick, use Subversion. Windows XP it really, really, really bad at caching lots of small files on an USB stick. Git writes many small files for commit operations and that takes ages on Windows.
[EDIT] The problem with Windows XP and files on an USB stick is caching (or the lack thereof). To prevent data loss, XP will always write files synchonously on an USB stick (so any write will come back only after the FS has reported that all blocks have been written to the stick). Add that to the fact that USB sticks are slow when handling small files (they have a lot of overhead initializing their wear level management) which leads to very poor performance for any kind of application which writes lots of small files.
[EDIT2] If you put a SVN checkout on the USB stick, you will also have a lot of small files (especially in the .svn directories). So the solution in this case is to put the Subversion repository (the "server") on the USB drive. The repository uses only a bunch of big files (if you use the database option instead of the file based one: svnadmin create --fs-type bdb). This avoids the "many little files problem". There is no way to achieve the same thing with current versions of Git.
Related
So I've decided it's probably best if I get some Source Control solution going to keep my hard work safe, and to help eradicate bugs between versions.
I'm familiar with SVN as far as checking stuff out, but I have NFI about the committing side of things.
What is a good Source Control solution, keeping in mind that I develop in Visual Studio on Windows? Should I get a hosted solution, or host it myself on my own server (running Windows Server '03)
I'd suggest using git and get Git Extensions for better Windows integration.
If you're just getting started and are looking to self-host, I suggest VisualSVN. It's a lightweight, extremely easy-to-use SVN server, and free. I've used it for small projects at work and home. It includes security, with folder- and file-level ACLs based on local or Windows users.
You may decide later to move to more powerful servers or an externally-hosted solution; you can just dump the repository from VisualSVN with the standard svnadmin tools and load it into something else very easily.
For the client side of things, I use TortoiseSVN and love it, and I understand Ankh has gotten better since last I used it.
Use git.
One workflow that git does really well:
Have an idea for some feature you want to implement
Create a new branch for that feature
Write code, commit like crazy
When you're done implementing, squeeze all the crazy commits into one big patch
Commit that patch against your main branch
Delete the for-that-one-feature branch.
This is wonderful to have. You can have multiple parallel branches for this, and it's really easy.
As an additional feature, if your project goes public and you use git, people who check out your code will have an easy time making their own changes to (their copy of) your code, version-controlled and all, and it'll easy to track upstream at the same time.
If not git, try some other distributed source control system and see if it does good branching and local commits as well.
We are a small team (seven people) we have been using a hosted solution (hosted-projects.com) for more than one year. It's cheap and has worked very well for us. We use tortoiseSVN for the clients.
The main advantages of a hosted solution are:
no need to worry about server setup and maintenance
remote hosting means we have a complete and up to date backup of our code on a remote location
very fast
I recently did a team development thing and we just hosted subversion on one of our workstations and it worked... passably. We used visual svn on the server, and tortoiseSVN on all of the clients (and I occasionally connected my macbook using Versions, SVNX, or the command line). Merging is the really hard part... we had a lot of trouble with that (resolved, once again, with some command line skill). I also set up my own subversion server on my linux workstation for personal use, which worked better (merges were smoother, only one developer). Overall, it has been fairly easy and merging is probably the largest problem you'll face.
If your new to source code then I would recommend you read Eric Sink's series on Source Control. It doesn't really cover distributed source control but it's still a very good primer.
I personally use Perforce. They allow up to two uses for free for home and small business use. It is a little expensive compared to others but there is reasons why companies like Google and Symantec use it. It has ok to good Visual Studio support.
I really like hosted solution because often comes with other tools like trac to manage your project timeline and bugs control.
I recommend projectlocker or codespaces
I work in a Visual Studio/.NET shop which is still using VSS 2005 for source control. We are looking to upgrade to VS Team Foundation Server and use it's source control system, but I'm curious if that's really the best option. The creators of StackOverflow use Subversion but comment that it's a pain to merge code forks back into the main product (discussed in podcast #52). Joel mentioned that Mercurial is used at Fog Creek. Knowing that Joel is something of a software snob and he chose Mercurial over anything from Microsoft, I thought I would pose the quesiton to the StackOverflow audience: which source control product is the best for Visual Studio developers?
We switched from VSS to SVN, using only TortoiseSVN for a long time. Recently we began using the VisualSVN plugin for VS (unfortunately not free).
I must say, after getting over the initial pain of not having source control integration in VS, I really liked the level of control I had over all my source control operations. I highly recommend this route.
If you go with Subversion and must have source control integration, I highly recommend VisualSVN.
If you want to give SVN a try, you can install the very free (and very easy to setup) VisaulSVN Server product and have SVN running in just a few minutes on a Windows server.
My recommendation is for SourceGear Vault. It's close enough to Visual Source(un)Safe to feel "comfortable" with right away, it's rock-solid (built on SQL Server which solves your backup hassles, too), it's very reliable, has great support for branching and merging - all around good stuff.
It's free for teams up to 2 devs and reasonably priced for larger teams - much less $$$ than Team System (also it's only a Source Control, of course - not a whole team dev system). We use it in conjunction with Fogbugz bug and issue tracker and that combo gives up all the bang we need for much less buck.
Highly recommended.
Marc
I've worked with VSS, CVS, SVN, and TFS.
VSS: Skip it. I've lost too many changes that literally have just vanished.
CVS: Great solution. Has one feature SVN is missing with a visual of the merging.
SVN: Great solution. You can get add-ins to integrate if you need them. I have only one complaint: merging between branches could be better. But, the product is bomber and very affordable.
TFS: Where I was working, they didn't do much with it. They only used the source control. I was excited to use it, especially the shelving, but I couldn't merge the changes to a branch. I would say it's pretty much what VSS should be. Sometimes MS tries too hard to do things for you that you just have to do for yourself. Also, the UI isn't intuitive.
So, I'd stick with SVN. Though, the new open source standard seems to be GIT (can't comment on it though).
It seems that you want to have VS integration but I question the reason for that.
A good source control product has many more features than just VS integration.
You can get subversion to integrate with VS ( Ankh svn and visualsvn ) and I've also used vault which is stable and integrated with VS but I use source control for other things other than just vs work.
So I prefer to work with source control out of the product. You should try it.
The source control is only part of VS Team Foundation Server, which is a complete project management system.
I used both SVN and TFS, and both of them are more stable, robust than VSS.
Coming from VSS any system would be an improvement;-)
Perforce is probably the best mainstream tool I have used. Rational Apex was even better, but unless you're writing Ada that information is of no use to you.
ClearCase is pretty powerful, but I found it pretty hard to use (admittedly I only used it for a couple of weeks, so I possibly didn't give it a fair trial).
For the cost (free) SVN is excellent. The Tortoise shell add-in makes it very easy to use in Windows.
EDIT.
I see I just got an upvote from this ancient answer :-) This caused me to revisit and I find I need to update my answer.
I now use TFS at work and I really like it, it's a big beast and not appropriate for home projects perhaps, but it's a commercial tool and worth a look if you really value VS integration. I'm sure Perforce and Clear Case are still great products too, but I am out of touch with those now.
For smaller projects or personal work at home I now use Git. I don't particularly care about VS integration though, I just use it from the command line, but at home I switch between several different environments so VS integration is not a priority.
I've had much luck with Ankhsvn. I'm able to use it interchangeably with TortoiseSVN and it does a great job of tightly integrating itself with Visual Studio and the project layout.
http://ankhsvn.open.collab.net/
We use plasticscm at work, it's less known, but very well integrated into VS, you have all the options and graphs inside vs itself.
+1 to forget about VS integration.
Many of the best source control tools have great command line interfaces. I've been happily using Git for VS projects for almost a year. The downside is that Git requires a bash shell and it is not very Windows friendly. I'm willing to pay the 'cost' of not having VS integration in order to get all the advanced features that make life really easier.
I would suggest giving Mercurial a try.
I have to add that this advice is more suited for a personal choice of source control. If you are looking for a source control standard for a big company with lots of developers, I would go with a more 'standard' choice like Team System, SVN or Vault.
SVN is better and faster than VSS. We switched from VSS to SVN 2 years ago because VSS was on servers in New York and the operations on VSS seemed too slow for developers in India. SVN is faster because it was meant for WAN as opposed to VSS which is for LAN. Refer this link
You can use windows explorer to perform SVN operations or you can use AnkhSVN to be able to perform SVN operations from VS.Net IDE.
You can prefer locking files before editing if you find merging them later to be a hazzle. But IMHO merging is really not tht painful, because you get to see the clear distinction between your and your collegues code before you go ahead with the merge.
Advantages of SVN can be found here on stack overflow.
I prefer TFSVC as it is integrated with all the other services in Team Foundation Server. But it depends on what you want to do. If you want an ALM solution, this is the way to go. I have the ability to set check in policies, integrated builds, and associate with work items. I like the way it does branching and merging. I can have my testers submit bug work items associated with the code in TFSVC. I have traceability to see who is checking in and breaking the builds. I can run reports and get good visibility into the project. Everything works together.
I hope this helps.
John
We use vault, Its good. But use Team System if you can b/c it's from Microsoft. They know how to deal with their own problems/bugs/wayofthinking.
My vote is for TFS. VSS is more than a pain. I have used SVN outside of VS and I would have to see it work along with it.
Working with source control out of the product? Sounds like more work than necessary. Just because it integrates with VS doesn't mean you can't use it for other things. If I am in VS I want to stay in there and not have to go over to another client application to get my source. I like that VS can check out directly.
It depends are you looking free or commercial version control system.
Subversion
Using Subversion you have great, free, open-source ankhsvn plugin which integration Subversion with Visual Studio. Integration is really fantastic!
Mercurial
If you need distributed version control choose Mercurial with VisualHG plugin. Mercurial, in contract to the Git, was developed with native Windows support and also Visual Studio integration is much better.
PlasticSCM
The best Visual Studio integration I have ever seen had PlasticSCM which is the simple consequence that PlasticSCM is windows-background version control system. It works really well.
I can't believe no-one has mentioned Assembla! It's free for unlimited repositories, unlimited users and 1GB of space!
www.assembla.com
Perhaps you should ask yourself what scm is best for your project.
I like svn cause its free and kind of standard(perhaps a little bit bold to say).
I use both Vault and TFS at work. We used VSS and others had issues with it, so the lead at the time decided to switch to Vault. I have had no issues with Vault, but others had some with merge and branch.
I started using TFS Trial and like it as much as Vault. I do not use many of the extras, such as the bug and work item tracking just yet, but plan to.
Since you did not mention cost and the comapny is already looking at moving to TFS, I would think that will satisfy your need of getting a product better then VSS and allow you to grow into it in the future.
I've used Visual Source Safe (2005) and I wouldn't recommend it. Being a file file based solution leads to the risk of your repository being more easily corrupted. I've used Source Off-Site a SourceGear product that enables remote VSS check-in and checkout over the internet and it worked well, but still had the disadvantage that it was built on top of VSS and the flat file architecture.
SourceGear also make Vault which is my preferred solution. It's a SQL Server based repository so it's not subject to issues with the Windows File System. Restores and backups can be configured just like any other SQL Server database and you can restore to a point in time, not just to your last backup date.
I've also used Source Anywhere (version 2.2) and I found it lacking in features compared to VSS and Vault. But it was a SQL Server solution, which made the backups more reliable.
I'm interested in trying Subversion and if there was a version of Subversion that used SQL Server as the repository I think it would be a reasonable solution. If you're running on another operating system, Subversion is probably your best choice, but if you're running on Windows Server I would recommend a SQL Server solution.
I am developing an application for the Mac as a small team (me + another person) effort. We are located in different cities, and have started to see the need for solid source control management.
None of us have any experience with this, and both of us are relatively new to Cocoa/Obj-C/Xcode (but do have C knowledge).
Does anyone have any recommendations as to which SCM system to choose? I understand that a lot of people are using Subversion, which is also supported in Xcode 3.1. Does anyone have experience with using Subversion through Xcode? Or is it a better option to chose a stand alone GUI alternative, such as Versions?
Grateful for any input on this.
Gregor Tomasevic,
Sweden
Update/personal experiences:
Since this post, we have tried Versions and Cornerstone (both of which are SVN GUI-clients), as well as Xcodes built-in support for SVN. We were not particularly pleased with Versions, which seemed to have some problems with committing unversioned files/build files. The built-in SVN support in Xcode works quite well, although it probably has limitations that we have still not run into. Cornerstone is both simple to use and powerful, and does not seem to suffer from the problems we encountered with Versions.
So far, we have just tried committing, updating repo, checking out latest/previous versions of our files and worked some with file comparison. It might be a whole different ball game once you start working extensively with branching, an area which we have been told both these GUI clients might have some weaknesses in.
For what it's worth (and with only days of evaluation) Cornerstone seems to be a somewhat better alternative, although for simpler SCM, Xcode works well too.
Thanks for all the comments.
Xcode only supports Subversion, Perforce, and CVS. However, there are also distributed version control systems out there, such as Mercurial, Bazaar, and Git. These have no Mac-native GUIs, but you should still consider them. Personally, I love managing my projects in Mercurial repositories.
[Added 2011-03-10] Xcode 4 adds support for Git. Several of us have filed requests for Mercurial support; you should, too, if you want it.
There is a nice GUI frontend for Mercurial on Mac called MacHG: http://jasonfharris.com/machg/
It is free and very nice IMHO.
You can't really go wrong with using Subversion.
If, like me, you don't like Xcode's SVN integration too much you can always choose to use the command-line tools, or one of the several GUI apps like Versions, CornerStone or SvnX. Most of these tools work together pretty well, so you're not necessarily tied in to the tool you start out with.
I personally do most of my work with Versions, and use the command-line tools with the same working copies every once in a while.
If you're comfortable working with command-line tools exclusively until someone creates a good GUI app around it, git is a pretty viable option too.
disclosure: I'm one of the people who work on Versions, so I might be slightly biased ;)
Xcode's Subversion support is pretty good. 90% of the SVN activities I perform are easily doable from Xcode. For the other few things I just fire up Terminal.
There are a couple things in their SVN client implementation that are annoying:
The code that checks to see which local files have been modified seems to run on a background timer, and its pretty latent. Sometime it takes 5 minutes for Xcode to show a file as modified. The same thing is even more exaggerated w/r/t remote modifications.
Sometimes when you rename or delete a file that isn't under source control, a dialog will appear, asking "Do you wish to [rename/delete] this file in SVN as well?" And the options are "Yes" or "Cancel." You choose Yes out of desperation only to be presented with a well-deserved SVN error.
Overall, I'd recommend it.
Caveat: If you simply tell XCode to add a project to a repository by giving it the top-level dir, it WILL add the build directory to the repository, which of course is a terrible thing to do.
In order to get around this you have to move the build dir to another location so that XCode won't try to import it, or manually add the discrete folders of a project one by one.
Subversion is the traditional OS X source control solution, in Leopard it's supported in Xcode and OS X, not to mention the third party GUI apps (a few of which look very slick). Despite all of this though, a lot of the independent OS X developers have switched to Git over the past year or two. As a single developer I can tell you Git has turned out to be a very good solution for me, and along with Github it makes a great solution for a small team effort.
If you're interested in using Mercurial on OS X, try SourceTree, it's not free but it's competitively priced and has a very polished Mac OS feel. I've been using it for personal projects for the last few months on and off and find it intuitive and reasonably robust.
It's available through the Mac App Store and supports Git and Mercurial. They have a website at http://www.sourcetreeapp.com/ with more information.
If your going for subversion, I've heard good things said about Springloops. I code together with some friends too in a similar fashion and we use Github. Git is such a wonderful experience. I don't use any GUI for it since I'm much more efficient with a shell prompt. But of course, I'd welcome if Xcode had support for Git repos.
Mercurial (like git) is "distributed" and perhaps regarded as more modern and up-and-coming than svn (but less established). If you want to auto-checkin using mercurial, you can add the line:
hg commit -m "Xcode auto commit"
as part of a "Run Script" stage of the XCode build, as found in:
Project > New Build Phase > New Run Script BUild Phase
I use : https://bitbucket.org/hsivank/xcode4-with-mercurial/wiki/Home
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
I'm trying to find a source control for my own personal use that's as simple as possible. The main feature I need is being able to read/pull a past version of my code. I am the only developer. I've looked at a lot of different version control systems, but they all seem way more complicated than I need. I need one that's simple, runs under Windows, and doesn't expose itself to the network.
Specifically, the version control system should not require exposing an HTTP interface, it should interact with the local filesystem only. It just needs to be a version control system geared for one guy and one guy only. Graphical UI is a plus.
Does anyone know of software would satisfy what I'm looking for?
Thanks!
-Mike
Subversion is great -- you can run the server yourself or use something like assembla.com to host your code (although that exposes it to the network).
There are numerous gui applications like tortoise svn that would allow you to interact w/ the source control repo
From what I understand, and at the risk of sounding like a fanboy, you might want to consider a DVCS (distributed version control system) like git or mercurial. They essentially take away the central repository part, so it should be ideal to use when you're a solo developer.
Another advantage is that when you decide to add people to your one-man team, you don't have to set up a central repository. All they have to do is clone your repository and they're good to go!
If you're windows based and are used to a shell plugin like TortoiseSVN I'd pick mercurial. Their windows integration is just a bit better than git's, using TortoiseHg. The git counterpart (cheetah) is on hold at the moment, due to the developer getting sick and tired of all the demands people were making ;-)
If DVCS is too exotic for this situation you could always rely on SVN. I've heard good stories about the already mentioned VisualSVN solution. Install, make some repositories and go. Install TortoiseSVN for shell integration, or perhaps Subclipse or ankhSVN for eclipse and visual studio, respectively.
Note: I have not actually tried git or mercurial in a real life project, just some test setups. I now have a simple project WITH version control (using mercurial in my case), without having to have access to a central repository.
Sourcegear Vault is free for a single user and you can run both the client and the server on your own machine.
Subversion with TortoiseSVN.
Like all version control systems, it will sound reasonably complex when you start off, but it's really very simple once you get into it, works well for a single developer, and doesn't require any network access if you don't want it to.
Plus, it's free.
For what it's worth, you can use Subversion & TortoiseSVN without a server using file:/// URLs to connect to you repository. I've done this to create repositories on USB thumb drives that I can move from machine to machine.
Here's a nice write-up: http://www.fredshack.com/docs/tortoisesvn.html
I use the free (2 user?) licence of Perforce. Powerful, fast, and well documented.
I'm a very satisfied user msysgit for Windows. It contains a recent copy of git as well as a GUI, a shell and a history browser in a single install package.
No need for a server component and if you do decide to host it somewhere your repository is signed and cannot be modified by the hoster without you seeing it. Finally, moving the repo to a server is a easy "push" operation which keeps all of your history.
You really can't get much easier than VisualSVN for version control on Windows.
I like to use Google Code, even for my one man projects, as it provides a Subversion repository already set up. Also, the server is offsite, which protects against hard drive failures and other disasters.
You might find Mercurial to be pretty nice for that purpose. You won't have to set up a server and creating the repository is as simple as doing "hg init" in the directory where your work is.
All the previous suggestions are pretty simple, and I know cvs is a bit out of vogue these days, but I like to use it's local mode for a repository that doesn't even need a server to install or set up. The repository can be anywhere on your hard drive. I have mine on a memory stick to have access to it anywhere even without an internet connection.
The key commands are:
cvs -d:local:/full/path/repository init
to create the repository
mkdir /full/path/repository/project
to create the module, and
cvs -d:local:/full/path/repository/cvs co project
to check out a local version.
TortoiseCVS gives you your Graphical UI
Bazaar. See Bazaar in five minutes for a great start.
Whenever you save a file, run the $ bzr commit -m "Added first line of text" command, and it's all taken care.
If you edit over FTP, make the FTP folder as a drive or folder, and bzr update after the commit.
+1 for Subversion, for those not familiar with it I would recommend the SVN Book.
VisualSVN Server is a complete installer for Subversion Server on Windows.
VisualSVN is a Visual Studio plugin for Subversion integration.
You could go with Mercurial.
It's very easy to start working with and there's TortoiseHg which integrates nicely with Windows shell.
You don't need a server for it as it's a distributed version control system - you can hold a whole repository copy on a flash drive and push/pull changes from it.
If you wish, you can put hg in a web server mode that makes the repository easily accessible over http.
As opposed to SVN and CVS, it doesn't spread its metadata directories all over the repository. There's just one .hg directory in repository root.
I use it daily and love it!
I use Subversion and TortoiseSVN — both are free. Your repository can be on the local machine. You don't have to work over a network.
However, for disaster recovery or even simple machine fault, it's probably a good idea to store your repository on a different computer and also back it up.
You might want to consider using a third party service to host your repositories off-site over the internet. I use CVSDude and am satisfied.
I am also a lone developer, and I use Subversion and TortoiseSVN.
Setup of Subversion is quick and painless; it can be done in less than half an hour including setting up the repository.
There is no requirement by Subversion to run on a server, I actually run it on my local machine and keep my repositories on a separate drive. Connecting to the repository uses svn:// instead of http://. I'm not sure why you require that it does not expose itself to the network, but this would be a matter of security via obscurity. I'm sure networking experts could suggest better methods for locking it down, should that be necessary.
Once the repository has been created, commits and updates from the repository are as simple as right-clicking on a folder in Windows Explorer.
Any distributed revision control system is best for lone developers, like git or Mercurial. Best thing is you can incorporate more developers to your project seamlessly, as opposed to having to give them access to your main centralized SVN or CVS repository.
SVN and TortoiseSVN work for me. Definitely ensure you have offsite backup.
You might want to check out the wiki article Comparison of revision control software. A (slightly hard-to-read) comparison tool might help. You might enjoy If Version Control Systems Were Airlines.
I came here looking for the same thing, and I saw someone suggest Google Code. I tried it out, and it was brain dead easy to set up. Exactly what I was looking for. Works like a charm with TortoiseSVN (my favorite).
I came here for a solution, Google Code was all set up in about 2 minutes. You can choose SVN, git, or mercurial for your version control.
You should check CVSNT as server and use any of the clients you would like (standalone or integrated with your IDE). There are plenty of them.
Use Visual SVN to setup your server and then use Tortoise to access your repository. Both are free to use and we have been successfully using it for quite sometime now.
#gorgapor: Doesn't the Google Code TOS specify an open source license? It's not a generally applicable solution in that case.
I haven't seen anyone mention Perforce. Perforce allows you to use their software for up-to 2 users for free. You can run the server and clients in the same machine, which will give you the environment that you want.
This is much the same question as Source control system for single developer
The bottom line is: yes there is. More than one.
My opinion is that SVN will do just fine. it does for me in similar cases, as described here: Single serving source control
I have heard of a hosted Subversion vendor Versionshelf (http://www.versionshelf.com) on a podcast I listen to.
This site also has a list: http://snook.ca/archives/servers/hosted_subversion/
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
My development team uses source safe at a very basic level. We're moving into some more advanced and extended development cycles and I can't help but think that not using branching and merging in order to manage changes is going to be biting us very soon.
What arguments did you find most useful in order to convince your team to move to a better solution like SVN?
What programs did you use to bridge the functionality gap so that the team wouldn't miss the ide sourcesafe integration?
Or should I just accept sourcesafe and attempt to shoehorn better practices into it?
Reliability
SVN is a lot more reliable with large databases
SVN is still actively supported
Atomic commit - in VSS when you get latest version while another user is performing checkin, you can get an inconsistent state, forcing you to repeat the "Get latest version" in better case, but sometimes when unlucky you may be left with a codebase which compiles but does not work. This cannot happen in SVN thanks to atomic commits.
Features
SVN branch/merge is a lot better
SVN has builtin support for remote access
SVN is more configurable (integration of external Diff/Merge tools)
SVN is more extensible (hooks)
Better productivity
SVN "Update" is a lot faster compared to SS "Get latest version"
SVN command line is a lot easier and cleaner - this is useful for automated build or testing tools
Same level of IDE Integration
VSS had a lot better VS integration until recently, but with AnkhSVN 2.0 this is no longer true.
Open
SVN is open and there is plenty of various tools using SVN or cooperating with it. Some examples include:
integration with many bug tracker or product cycle management products
shell integration
integration into various products
various management and analysis tools
source is available, you can adjust it to your need, fix the problems (or hire someone to do it for you) should the need arise
Cost
You do not have to pay any license or maintenance fees
First, teach them how to use SourceSafe in an efficient way.
If they are smart enough, they will begin to love the advantages of using a version-control system, and if so, they will soon reach the limits of SourceSafe. That's where they will be the more able to listen to your arguments for switching to a better VCS, could it be a CVCS or a DVCS, depending on what's the team is ready to achieve.
If you try to force them to use another VCS when they use SourceSafe in a wrong way, like saving zip file of source code (don't laugh, that's how they were acting in my company two years ago), they will be completly reluctant to any argumentation, as good as it could be.
Find some excuse to start using non-ASCII characters in your C# code (Chinese and Japanese are excellent for this).
SourceSafe doesn't like Unicode (even though Visual Studio does), so if you choose the right Unicode text and check a file in and back out, your entire file will appear as corrupted gibberish. The beauty of this is that because SS uses a "diff" versioning system, this actually corrupts the file all the way back to the original check-in version, and can't be fixed automatically.
When this happens just one time (as it did to me when working on an application that had to support Japanese), you will probably find it to be a decisive argument in favor of dropping SourceSafe.
There were two features that we used to sell management and the team on SVN over VSS.
1) The ability to branch. When using VSS, when a release was scheduled to go out, the entire repository was locked until the release actually went out. This included the test and fix cycle. So, developers were unable to commit anything other than fixes for the release to the VSS repository. This resulted in long integration sessions immediately following each release. With the use of release branches in SVN, there is no longer any need to lock the entire repository.
2) The ability to rollback an entire change at once. Because SVN records all files changed in a single, atomic commit, it is trivial to revert a problematic change. In VSS, a developer had to go through the entire repository and find every file changed at about the same time and revert each change to each file individually. With SVN, this is as trivial as finding the relevant commit and hitting the "Revert Changes from this Commit" button in TortoiseSVN.
As a side note, we use TortoiseSVN and everyone loves the file overlay icons for seeing what has and has not changed.
Whatever you do, move slowly! Don't start talking to them about branching on Day 1 -- it will just put them off. I'm stereotyping VSS users with that comment, but that's what I see out there.
For the developers: sell it as a replacement for VSS that works better and faster. Use VisualSVN on Day 1 so they have a super-shallow learning curve. Sell them on it being the same except faster, more stable, and 2 people can edit the same file and they won't have problems with some guy being off sick with locks on a bunch of files.
For the admins: sell them on it being more stable and easier to administer than VSS. Show them VisualSVN server.
Good luck!
First, document all the problems you are having that can be traced to root causes within the source control system. Keep track of them for a month or so. Add on top of that missed opportunities resulting from not using it. (if you say "opportunity costs of not using subversion" you may impress an MBA-type manager). These numbers are actually an understimate of the opportunity cost because presumably you could have been doing work that provides more than your hourly bill rate of value if you weren't messing around with VSS.
For example, do you have problems where files are locked that need to be accessed by more than one person?
Have you had problems with partial (non-atomic) check-ins?
Do you have problems where it is difficult for you to keep track of releases of the software and recreate the repository as it was in the past?
Do you have problems getting a copy of the code onto a server that doesn't have a sourcesafe client?
Do you have problems automating your build and testing process because continuous integration tools can't monitor your version control systems for updates?
I am sure you can think of many others.
If you can figure out the approximate time/money costs of problems caused by sourcesafe and benefits of things that subversion provides (using a generic number like $100/hr for labor costs or just hours) and any costs of late delivery of projects, do so. If you have collected data for a month or so, you can show the benefit using subversion per month.
Then present the approximate time/cost of moving to subversion. (About 8 hours to setup and migrate code, and 2 hours per developer to connect, checkout and move projects, something like that) The risk is low, since sourcesafe is still there to rollback to.
If the cost is more than the monthly benefit, you can divide the cost by the benefit to figure out the recovery period. You should also total it up over 3 years or so to show the long term benefit. Again, emphasize that the real opportunity cost is not directly calculable because you could have been adding value during the time you were trying to manage non-branched releases in sourcesafe.
Nobody recommends using SourceSafe any more, not even Microsoft. They will now offer you an (expensive) TFS licence instead. SourceSafe is just not reliable.
I wrote about it here: Visual SourceSafe on E2. It's a bit of a rant, but that's because I had to use SourceSafe for quite a while, and the memory makes me froth at the mouth a bit.
Reliablity is the big one that will bite you. But also there are features that you may appreciate in SVN or TFS:
TFS and SVN both have atomic commits of multiple files, but Sourcesafe does not - if you check in two files "at once", it's not one operation, it's the same as checking in one of the files, then checking in the other. You can get at the state in between, where one file has been checked in, but not the other.
SourceSafe does not keep history of deleted files, file moves or renames.
Contrary to initial impressions, SourceSafe does support multiple simultaneous checkouts of the same file, if you set the right options. But TFS and especially SVN are better designed for this way of working
Unlike SourceSafe, TFS and SVN both work fine against servers on the internet (TFS just OK, SVN excellently) and SVN works well offline - e.g. if you have a laptop on a plane or train and no 'net, you can still work and compare to previous revisions or even revert, since the data to do that is held locally.
As someone else pointed out, SourceSafe, like CVS, is a "dead" product. It is not being actively developed. TFS and SVN will have next versions out some time in the future.
First search google for the sheer quantity of pages describing how bad VSS is and share that with your coworkers.
Second, skip subversion and go straight to a proper distributed SCM like git or mercurial. Because merging is such an inherent part of distributed SCMs, they have to handle merges much better than centralized systems like svn. Subversion is still trying to retrofit itself to handle branching better, where the distributed systems were built correctly to begin with.
The AnkhSVN plugin for VS is pretty good. It's got a few oddities but on the whole works well.
Convincing the team to move is hard work - I never managed it :-( Probably one of the more practical arguments though is speed - VSS is s-l-o-w when you've got a 1GB source database and several users.
edit It's been so long since I used VSS I forgot it was locking! Yes, as mentioned here the ability to move to a non-exclusive/merge changes model should help if you've got more than a handful of developers. It saves yelling "Can somebody check in the common includes" across the office!
You say "What arguments did you find most useful in order to convince your team to move to a better solution like SVN?"
If you don't know that it's a better solution, then why are you making the arguments? If your mind is made up enough to go argue for a solution, you should know what those reasons are already.
What convinced you that you should move to something better? Those are your arguments right there. Anything short of those arguments will sound like it's just an issue of personal preference.
TortoiseSvn (free) is really nice for explorer integration, giving you all the features of svn from a context menu.
VisualSvn (commercial) makes it just as easy to integrate svn into Visual Studio, with the same status indication in the solution browser as well as context menus to use all the subversion features.
Both these tools go a long way to making version control seamless. It's been a coupe of years since I dealt with VSS, but these tools are a way nicer way to use source control.
Ditto for what every one has said about VSS being poop
Subversion has good support for branching and doing merges... I don't remember VSS having any capabilities in this department at all. I do remember teams going through pain of week long merges when needing to release from VSS, pain which just doesn't exist anymore with Subversion.
Build some automation that mirrors the VSS repository into a SVN repository
It takes time to build a consensus. If your SVN mirror of the VSS repository is available at all times, it will be easier to accumulate converts. The mirror doesn't have to be perfect- it just has to be usable. There are existing tools for this purpose.
Tell them to treat the source code as if it was money and point them to the numerous examples of SourceSafe coming down in flames taking the source with it. Things like that are just not supposed to happen in a proper source control system.
The best argument against SourceSafe is that it is just isn't Safe, everything else can potentially be called "features we don't need".
The clincher for us was the speed (i.e., the lack thereof) of VSS over VPN and low bandwidth hotel networks on the road and the problems of trying to tunnel through firewalls so that two teams at two different sites could quickly, securely, and reliably work from the same code repository. We were running two VSS repositories and packaging up "deliveries" that had to be merged into the other site's repository to keep them in sync.
The team grumbled for a while, but quickly got over it. TortoiseSVN is fantastic by itself and the AnkhSVN plug-in for Visual Studio really eased everyone into the changeover.
Looking back, I can't believe how many "Can you check in file SoAndSo?" e-mails we sent around, not to mention the "SourceSafe is down. We've got to restore the repository" e-mails.
Sheesh. After reading this comments and writing this response, I can't believe we put up with VSS for as long as we did.
Web page summarising problems with VSS - just point people to that URL
If you use VisualSVN the team won't miss VSS as much. 2 people being able to work on one file at the same time is a big selling point too.
The unreliability of source safe ("please fix the repository...") was enough of a sell for us. Andecdotally (I've never measured it) SVN also always seems faster. Good concurrent checkouts / merging.
I'd always figured that to a developer it was almost too obvious. SourceSafe just seems to break and die all too often to not want to replace it...
Tell them to read this http://www.highprogrammer.com/alan/windev/sourcesafe.html
I would recommend that you go ahead and start introducing best practices to your sourcesafe usage with a view to changing to subversion further down the line. Hopefully this will make your actual subversion migration easier and give you time to sort plan out your development cycles, branching strategies et al. properly.
The other thing to consider is your development process in general. A source control management system is only ever part of the solution, to get the most out of subversion or any other product you will probably want to look at how it's usage interacts with your code review, qa and build processes.
I don't remember any SourceSafe user ever liking the product. Do your colleagues actually like it?
I've got a similar issue with CVS at my current customer's usage. Since "it works" and they are mostly pleased with it, I cannot push them to change. But daily I sure wish they would!
When I was at the launch for VS2005 I managed to corner a Microsofty and ask why SourceSafe was so awful to use. The reply I got was rather shocking, not just because of what he said but because he was so up front about what he'd said.
He told me that it was only really meant for one person to use and even then it wasn't very good at doing that.
My colleagues and I were a bit shocked we couldn't think of much else to do other than laugh out loud, as did the Microsofty! He then told us that it wasn't used internally.
So, we switched to subversion shortly after that. We'd pretty much decided to go for it before the launch event, but that just confirmed we'd made the right decision.
We used to use SourceSafe. Then, when I joined the team I was in a different location and even though we have a fairly good LAN when I tried to check out the latest version it took 40 minutes. I persuaded them to convert to CVS (we now use SVN) and the checkout time dropped to a couple of minutes. SourceSafe was just too slow to be usable at a remote location.
We moved from SourceSafe to Source Gear Vault. This source control engine is very comfortable for some one used to SourceSafe. We finally decided to make the change after a couple SourceSafe corruption incidents, that came at critical times. So my advice would be to focus your sales presentation on SourceSafes unreliability.
Surely using source safe is enough reason to want to migrate to another source control system?
I used SVN and CVS at my old job and have moved to a company that uses Source safe (we are going to migrate to SVN) and just using VSS has been enough for me to take a serious dislike to it. I went in with an open mind, despite many of my colleagues from my previous job telling me horror stories about VSS I assumed that it would have gotten better since they used it.
Not being able to edit a file because somone else is/was editing it is ridiculous. I've tried to move to more distributed versioning systems like Bazzar which is made by cannonical however it's not mature enough in terms of the tools available.
Source safe gets in the way of development where SVN helps you almost every step of the way.
Plus Using tortoise Svn made code reviews a lot easier.
Only to the extend as you are able to herd a bunch of cats. I've been there twice and in both cases it took some serious problems in Source Safe before people saw the light. As a manager on the other hand I simply directed the team to use SVN and our productivity increased by 300% ( this was working with a group in India and in the US. We had code exchanges that used to take a long time before svn )
Also Trac mounts on top of Subversion. It's free and a great way to view the repository (timeline, wiki, etc)
As you're making these arguments, consider whether you need to address any policy your company may have about using open source tools. See this answer to a prior question: Switching source control
Make them use it and they will switch to something else :)
Now, being serious, tell them its not that hard to use it, many developers that I've known refused to switch because they related subversion to unix and wierd commands, show them interfaces like ToirtoiseSVN or VisualSVN, tell them that Subversion allows them to edit the same file withouth a forced locking like VSS does.
And last but not least, it is Open Source. It has lower cost than buying Team Foundation Server and if you look around you will see that small teams of developers work quite well with SVN.
I used SourceSafe on a small development team and was responsible for keeping it running.
I found the database gets corrupted pretty easily, and there isn't much recourse when that happens. The "repair" feature (as with most any Microsoft repair feature) just doesn't work 98% of the time.
Naturally, when our database became corrupt, we tried to restore from our backup archive. That was when we discovered the other bad thing about SourceSafe: its 2GB archive limit. We were making backups at our office for months before we ever realized that they couldn't be restored and were useless.
SourceSafe is just a disaster waiting to happen.
I'm planning on ditching SourceSafe in the next few weeks, after over a decade of putting up with it. Mostly I've been using it within the context of a small (< 5 person) team, and not had to do a lot of branching because there's been no call to do it.
However, the #1 problem for me, and always has been, is that the damn thing is so prone to corruption - if you have your SS database (lol, database; collection of randomly named files more accurately describes it) on a network drive, and something happens to your LAN connection partway through an add/checkin operation - 9 times out of ten you get "invalid handle" and the damn thing is corrupted in some way, and then you get to play Russian Roulette with the Analyzer tool.
I realised, a couple of months back, that for the past decade I had been making local zipped up copies of the source at every release of the software I was working on, because I didn't trust the source control system. What a waste of time.
So, it's going. I'll probably use Subversion and TortoiseSVN, because I think the team will need a UI to ease the transition.