Related
I have been dumped in the deep end at a new job and I need to create, administer, and use TFS projects currently in some disarray. I'm looking for recommendations on good books, tutorials, articles etc. on using TFS as integrated with VS 2010 (and otherwise, but not s priority).
Given that I don't enjoy most beginner oriented and 'for dummies' material, what resources should I be looking at?
Books might give you a pretty decent general background, but my take is Team Foundation Server with Visual Studio 2010 is still a bit of a moving target (i.e. the specific issues in the TFS build that your employer is using may not match the TFS in a published book; you may want to check the configurations of your installations...). Of course, almost all software starts being updated Scrum-style before the latest update is pushed out to users anymore, but my "moving target" characterization of TFS is probably more appropriate than for the average development tool ... maybe not; it may not matter that much to most people that TFS is still a bit "fluxy" ... Brian Harry might use a different phrase, but I'm guessing that he would ascribe the TFS "fluxiness" as reflection of his recent pronouncement that TFS is open platform with lots of different things going on, lots of different moving pieces. We are all open source now!
If you are a glass-is-half-full kind of a guy like I am, you will see this "moving target fluxiness" as actually sort of a cool thing -- exciting improvements and great new features will be coming your way; you might even get to find new features, help make those improvements happen. Hopefully, nothing will happen to destroy a project your employer is counting on and sink you any further into the deep end in your new job -- look on the bright side, you may gain a profound sense of empathy for your predecessor before this is all through. There are always all kinds of positives in situations like this!
If you were a miserable cynic, you'd say that if Boeing built planes like Microsoft builds software, thriving ecosystems of "development" passengers on airliners would have hands-on (i.e. white-knuckle, death-grip) opportunities in every flight -- they would be involved in discovering and improving mechanical, electronic, hydraulic design features or maybe learning about something new related to a supplier issue, a new failure mode, new mfg and maintenance issues. Don't be a miserable cynic -- sieze the day; embrace change, you're in the deep end already, you might as well swim to the other side, right?
Since there will be a lot of people at Microsoft serving the MSDN community and trying use/build/tailor/improve the TFS "open platform" (to "eat their dog food," so to speak) you won't really know exactly where the best developments might come from ... I would routinely follow a search of all MSDN blogs for the "Team Foundation Server" keywords ... in my case, I pasted this RSS url into my RSS reader.
This book is from some of the MSFT guys. It is really good.
http://www.amazon.com/Professional-Application-Lifecycle-Management-Programmer/dp/0470484268
Visual Studio 2010 ALM Virtual Machine + Labs: December 2010 Refresh
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
Clarification: I'm referring to companies that pay developers, professionally. I understand why a "hobby" or "for fun" developer wouldn't want to (or couldn't afford) a fully-features pay tool, and may prefer to tinker. I'm talking about situations where a deadline is bearing down on a developer/company and development time is diverted away from the goal in pursuit of a "Free" tool to accomplish what a pay one is available to do.
I've noticed a number of Stack Overflow questions recently (they're not new, I've just recently taken notice) where people are searching for free alternatives to popular development tools for things like ALM, database comparison, and other functions for which there's a trivially costly pay alternative. The "Free" tag on Stack Overflow has 350 questions, and it doesn't take long to see dozens of examples of "Is there a FREE tool to do X?" followed by discussions that must have taken the asker hours to research and participate in.
It's not just about paying less - I'm often amazed at the hoops that some developers (or, perhaps more accurately, their companies) will go through to avoid paying for something - in some cases, a pay solution will be avoided in favor of a poorly documented, buggy, feature-incomplete open-source solution that results in dozens of hours of work that could have been avoided.
I understand the most obvious reasons:
Company is short on cash
Don't pay for something when a (functionally-comparable) free alternative is available
"Hobby" developers don't have the cash to spare, and since they're just learning, it doesn't make sense to pay for a toolset they're only tinkering with
However, I think the "short on cash" reasoning is completely bogus - as a developer not long out of college, I made about $50K annually, or $200/day (meaning my company probably paid close to $300/day to have me in my chair, all considered). When you compare that price to a $300 tool, the obvious answer is "if it's going to waste more than a day of your time, you should buy it instead and get back to work". However, that's not what I observe - people seem willing to kill dozens of hours to avoid paying for something that only costs $50.
Help me understand - as a developer myself of tools I'd like to one day sell, I want to understand the mentality. Have I been spoiled by working at a company that's not afraid to spend? Is there an ingrained reason developers (or their companies) don't want to spend money? Can people not accurately estimate the costs of "Free" tools in terms of lost productivity?
I'm not referring to instances where a great free alternative is available. For example, any of these tools is a great example of something you shouldn't pay for. However, let's say one of those lacks a key feature you need, and which a pay version of the same library provides - people seem to lean towards hacking around with the free version to add the needed functionality (or scaffold in the needed functionality) instead of ditching the free tool in favor of the pay (and feature-complete) version. I'm not saying that's the wrong choice, but it's just a choice I want to understand the reasoning to. The important point is that I'd like to - my intent is not to be argumentative.
What you're not considering are Dependencies and Partnerships.
It's great when companies announce "Partnerships", their marketing and legal teams spend ages wording contracts and press briefings that basically announce "We're now joined at the hip!".
What you may not realise, is that every time you choose to use a 3rd party tool you are tying yourself to that company, unlike a partnership the dependancy only goes one way (like the Marketing and Legal blurb).
What happens if they decide to cancel the product?
Or they change how it works, and suddenly it's not compatible with how you are using it?
Or they double their yearly developer licence?
Here we use lots of open source tools, while there is only "community level support" and the ramp up time may be longer than for an off the shelf tool, we consider that worth the price we're paying.
We are part of that community. If a version is released that breaks our software, we have choices, we can continue with the version we're using, and choose to maintain that version our selves. Or we can participate in the project and patch the code so it will continue to work for us.
If the open source project falls by the way side, we're still left with access to the source code, so we can continue to build and maintain that too if we wish.
We believe going open source gives us far more freedom than tying ourselves to other companies, who can (and do) change their pricing policies.
Cost-per-developer next year could be twice what it is this year. Changing to a different product could equally cost as much or more.
My two cents.
Where I work I can download the free opensource tool the minute I find it. I don't even have to tell my boss that I'm using it.
If I find a non-free tool I might be able to download a free trial, without telling the boss, but if I want to buy the full version of the tool I'll definitely gonna have to talk to my boss and he's not just gonna give it to me. I'm gonna have to motivate why I need it. He is definitely gonna ask if there are any free alternatives and "I don't know." is not a good enough answer. So if I want the non-free tool I'm gonna have to evaluate all the free tools first.
If I convince my boss that I need the tool, he's gonna send a request to another department that's in charge of this kind of purchases and he's gonna have to convince that department that our department needs the tool. Usually not a problem, but sometimes it is.
Anyway, when we tell our boss that we need something it can take weeks before we get it. Therefore it's often much quicker to just use a free opensource tool and not bother going through that process.
I imagine that other work places might have a similar situation.
Two points to consider:
You're a professional software engineer. Not everyone interested in software development is. For some people, this is a hobby... and paying a few hundred bucks for a profiler (or whatever) just isn't worth it.
You're in the US, and assuming US-style income. That's far from universal.
First off, not everyone asking may be funded by a company.
Second, despite the time savings, ideally the salary for an employee is a sunk cost, it's already been budgeted and allocated. There very well may be "no more money".
When you look at licensing, that $300 thing is $300 for Tom, but then he can't let Joe, Frank, and Bob use it. All of a sudden, if the tool is popular, now it's even more costly. It's not like buying a stapler. And then you get back to what was ostensibly a petty cash purchase now becomes a capital purchase.
A free tool can be downloaded and used instantly (usually). Buying even a $50 tool can take a week getting the check from accounting, THEN it can be downloaded.
Finally, many times folks are looking for some little specific piece of a tool, not the entire suite. Yet they're forced to purchase the entire thing. The Whiz Bang Ka-Blammo Enterprise Tool Set when they're only interesting in the 17th bullet point off the feature list.
I'm never afraid to go to my boss at work and ask him to pay for some tools that will help to make me more productive. However, the work that I do for myself, and much of it is as complex as what I get paid for, has to be done with free or nearly-free tools. I have paid for some things where the cost-to-value ratio is really compelling, like Wing IDE for Python development. Visual Studio, on the other hand, is so expensive that I just can't rationalize the cash outlay no matter how great it is.
I certainly appreciate the rationale behind this question. If you are thinking about being a professional tools developer, you have to wonder if it is going to be possible to make any money at it. I would say that you have to very carefully consider what you charge for your products. While you can charge enterprise-class customers hundreds of dollars for a tool, and they won't blink at it, making the sale in the first place is an enormous challenge. With my startup company, we found that it took about a year to go from first handshake to getting a signature on a check. That's a long, long time when you are starving and living off of your savings.
On the other hand, if you can charge less and make it a compelling purchase for an individual developer who is reaching into his or her own wallet for a personal credit card, you can achieve the kind of decision-maker mind share that can greatly short circuit the year-long enterprise sales cycle.
A developer is paid, and generally motivated, to develop stuff.
Picking up a free library takes a bit of research, but then you can pull it in, try it, and keep doing that until you find one that fits. The process of selecting the appropriate free library/tool fits well into the developer's skill set.
In a business, you're right that it's possible to buy good tools. However, to do this you need to make a business case for the cost, and persuade your manager (and probably further up the chain too) that it's worth paying. This requires an entirely different skill set, and one which would take many developers outside their comfort zone. Most of the time, I think developers just can't motivate themselves to start down this route.
Even if "the company" might want to spend money on tools if it's cost-effective to do so, the average developer is not correctly motivated to support this company goal.
Going back to your original question, you were interested in how to sell development tools in this climate, when developers have this tendency to pick the free ones. Based on the above I see two options:
Make it compelling to the developer, so they think it's worth the politicking time to get their hands on it. Time-limited trial versions etc can help here: once the dev has learnt the tool and seen what it can do, they'll not only be happier to ask their boss to spend the money, they'll be better prepared to justify the spending in terms of time already saved.
Make it compelling to the manager, either so the developer knows they'll have an easy sell if they ask, or to skip the individual developer level altogether and sell directly to management. Anything with "enterprise" in the name is taking this approach.
I think there's a mental block against paying for something when you can develop it for "free". I think often developer time is seen as a base cost, something you're paying for anyway, so the additional time spent developing a tool isn't seen as an additional cost, it's something you're already paying for.
The complete opposite exists too. Some developers will blindly buy the first thing they bump into. But I think a lot of developers have various unhappy experiences with paid-for software. Community support can suck. Paid support can suck. Some people get disillusioned with the whole closed-source thing and prefer something open source just because it's open source.
As you're focussing on trying to eventually sell something, here are a few tips to convince people to stop hopping once they've found your wonder product:
State the features. I've too often found a site talking about a widget that just bombards me with latest news, changelogs, prices, yada yada... But doesn't tell me what it actually does! The first paragraph should concisely explain what it does.
Provide lots of example code, sample projects, documentation. Tons of it. The more use-cases the better. Now of course you also need to provide a navigation system so the user can find things but the more examples, samples and docs you provide, the quicker the user can test your whatsit.
Trials make the world go round. If you can, make sure I can test it before handing you any money. If I can't, I, personally, won't be buying it. Money back guarantees come in a close second but as I say, if I can't test it out, however good it looks, you're not getting my money.
Companies I've worked for look for free alternatives (and usually I mean really free, not just free of charge) because "pay ones" often have (or get over time) restrictive licenses on redistribution. I don't want to base my whole product around a for-pay library only to find out that I now have to pay them $1000 per copy I sell.
As a matter of fact, I earned a bunch of money last year porting a product that had been written using a third party web crawler/indexer over to use Nutch instead because the person who'd paid for the product to get written in the first place didn't realize that the third party web crawler/indexer was going to cost her more per license than she was planning to charge for the whole product, and because she also didn't realize that the third party product was built for intranet rather than internet crawling and so ignored robots.txt.
Some times the "management" does not want to buy anything for the "developer" thinking that the latter is getting paid to develop the software. I've been in situations like that and it was really hard to convince the mangement to buy a set of UI controls we needed for a web application.
I personally prefer free tools, because learning how to use a tool is not 5 minutes. to really master the tool you need to spend a lot of time using it. Id rather not waste time in learning something that is not universal and cant be used always. learn once, use anywhere.
Many of those payed software is not that amazing for me to fight with my boss for it. Total Commander is the only tool that is worth the fight, however from time to time I look for free alternatives and I even consider writing one myself.
When was the last time you read your GNU manifesto. Has the concept of copy left been forgotten? Maybe you've forgotten your roots. The world of software development started from the sweat of the "hobby" or "for fun" developer. Remember those two developers in their garage who later made and sold those operating systems? It is not only a part of our heritage to hack out our own solutions but it's in our blood as well.
Also, companies of the pay-to-use solutions are trying to make money. While a good business model will include helping the customer achieve their goals, making money is their first priority and has a good chance of getting in the way of development progress. The free to use community on the other hand, from what I understand, is purely altruistic and has only the utility of the software thing in mind. The community of free-to-use, copyleft, open-source is very strong.
Ideas/concepts were meant to be shared (freely) to advance us as a people.
Sometimes you need free tools if you are not sure will the result bring you enough money. For example you established startup that works on creating app (or site). They don't want to spend money on third-party tools because they can't be sure will it bring money or not.
Another case, i once worked for big company and their budget approval process took too long, i have to find free stuff at least on initial stage.
Have you noticed that most free tools come without warranty (see GNU Public License, v.2) or support? I use tons of 'free' software every day, because as a hobby, I like to develop too. And a good application always gets bought, but back to the why's.
The FOSS community is a large one, most applications are free. Hence, it wouldn't be a strange question to ask for a free or an open source alternative, because well, there are a lot.
A free ride is always better than a paid one. Depends on the attraction, though. Some paid ones are better or far worse. (Babes, Photoshop, Dreamweaver, Vim) comment: "Babes" is not a program.
Some commercial applications require you to pay by creditcard payment. I hate online payments, and I double hate creditcards. I triple hate how companies store my personal information.
Not everyone is a software engineer. Some of us, do this just for fun :D (Linus Torvalds, Matz, Guido, Larry...go on, go on....)
Another line of thought here is how well are those superior pay ones known to everyone? For example, how am I supposed to know every kind of add-in that Visual Studio has? While some may say, "Well, you aren't," then this is another reason for some to not find those great tools out there. Some may be easy to discover and others may require one to know some jargon phrase in order to use some Google Fu to find it.
Another point is what some companies may or may not realize about how they are spending their money. For example, some developers may have some pretty sizeable hoops to go through to get the company to buy licenses for some tools, especially if every developer would have to have a license and some aren't that cheap to get. How well the managers know what their developers are actually doing and what kinds of changes could be made for the better with a little money could shock some people while in other cases the learning curve on using the tool may also be seen as a barrier in some ways as well as another thing to keep track since some tools are available on a subscription-like model rather than an outright buy it once model.
Seemingly since that time when programming and development came into existence there has been an ebb and flow between the commercial and the non-commercial -- these days more accurately described as 'corporate America' and the 'open source community', respectively. I personally chalk all of that up the existence of middle men and profiteers.
On the subject of freeware, I feel as '01' above -- a free tool allows evaluation at my own pace, potentially preventing the waste of valuable funding, which is an important consideration in this current economy.
Shareware is a fine balance, but I personally find most software doesn't provide adequate time for evaluation. Most tools I download are 'once-a-month' endeavors at their highest frequency so plunking down $30-$60 (U.S.) seems unjustified until I know the tool lives up to my desires.
And regarding professional tools, we all know the goals of business. I find the terms and conditions of Scooter Software to be most logical and accommodating. I've used their Beyond Compare tool for years and years -- as a developer invaluable I've found it both valuable and unequaled.
As to your personal dilemma, make your tools good enough, offer good shareware evaluation terms, and charge a reasonable price for it. Choosing popular (and multiple) platforms also doesn't hurt... consider the number of folks who've made a mint selling iPhone applications, regardless of those applications actual utility.
I'm talking about situations where a deadline is bearing down on a developer/company and development time is diverted away from the goal in pursuit of a "Free" tool to accomplish what a pay one is available to do.
This is exactly the situation when you can't use a paid for tool because petty cash/expenses won't cover the cost and getting budgetary approval takes weeks to come through.
Number three from 9 Ways Marketing Weasels Will Try to Manipulate You. It's "Free"! People make irrational decisions about free stuff.
I think that it makes a lot of sence for companies to try to use free/open source products for the following reasons:
Reduce the price of the deliverable product. Why would you expect a customer to buy something that works with a proprietary database when the company can bundle MySQL for example for free? So the company can lower the price and be more competitive.
Usually when buying software/tools, there are proprietary issues.
Usually when buying software/tools, there are dependencies to other also non-free modules.
There are other reasons also, like that IMHO it is considered "trendy", but the most improntant is that the use of free software can cut down the final prices, helping the company gain customers.
It is also important to support the free tools by adding to the momentum of it, sometimes by the simple fact of starting to use it. By finding/reporting bugs, or more importantly, fixing them and giving patches back, you improve them in a symbiotic relationship that benefits both your company and the tools you decide to use (and hence everybody else who also use them).
One good reason to look for free tools is to get a complete overview of the available options. I'd say that's a reasonable thing to do before you buy a product. Commercial software vendors have advertisements, so you'll probably find those, but there might be a great free alternative that you never heard of. It makes perfect sense to check that, even if you are willing to spend money on software tools.
Plain and simple some companies like IQPC.com will not spend even $10 on software and it's even hard in places like this to find a pen or pad to take notes.
I shed a tear for those who have to live like this, it's not easy.
I'm looking for feedback from .Net developers who have experience with Aldon as a lifecycle management platform. We're seriously considering using Aldon for lifecycle management including source control, automated builds, etc. I know there are a lot of other options out there, but ours is primary an AS/400 shop (with AS/400 programmers outnumbering .Net developers 6 to 1), and Aldon is used already by our iSeries team. The benefit we're looking for is having one lifecycle management suite.
Basically, I'm looking for opinions from people who have used Aldon and another set of tools (perhaps TFS, or a combination of SVN, Cruise Control, etc). If you've worked with both, do you have a recommendation on whether this is a good idea, or a bad idea? It's obviously a big choice, so any feedback would be helpful.
Edit - Added
No answers or comments... AND my first Tumbleweed badge. I'm not sure if this is just a bad question, if nobody actually USES Aldon to manage their .NET work, or if there's just nobody using Aldon that used other products and can offer a comparison.
So, I'm offering a bounty to sweeten the deal, and broadening the scope of the question... If there are any people out there USING Aldon at all, can you provide any information on issues you have had, is it a good suite of tools, frustrations, or gotchas, things you love, etc?
Added -even more
Our primary goal is to have one product to manage both our .NET and our AS/400 (primarily RPG) development. If you have a suggestion for a different suite of tools, or have tried it and decided it isn't worth it, I'll take that answer as well.
I'm working in a shop similar to yours--in our case, there is a substantial legacy code base of iSeries COBOL code, and a growing number of .NET systems--and the .NET developers have successfully lobbied to use Subversion for source control. In my admittedly brief time evaluating the product, it seemed like Aldon was not very flexible at all in areas like branching and tagging, and has a very cumbersome and arcane interface. Since product lifecycles are (mis)managed separately in our shop anyway, limiting the .NET use of Aldon to source control only, it was a simple decision. In the .NET world, Aldon lags far behind the standard open source tools in features and usability, and has no hope of competing with TFS. In our case, managing .NET code outside of Aldon has definitely increased developer productivity and decreased frustration.
One example...coming from a Subversion shop, I was trying to find out how to create an experimental branch in Aldon. If it is possible at all, the documentation did a great job of obscuring the feature, and our Aldon admin had never come across the concept. Everything in our shop is locked down tight, with admin rights needed to create projects, versions, etc. This might be worthwhile from a lifecycle management standpoint, but from the perspective of a developer trying to get work done, it is a killer. I don't think lifecycle management and source control belong in the same software, and Aldon has done nothing to dissuade me from that opinion.
I think you will find nobody here uses it. .NET people fall into two categories - those that are "cheap" (i.e. trying to save costs) and then basically you look or something like open source. And those who pay a lot, and most of those go with Team System - because it is ingtegrated into Visual Studio from the bottom up. AS/400 is a pretty rare intermix for .NET developers, so, at the end - you possibly are just out of luck.
I Personally am not sure I would even bother with it. THere is a lot more to soemthing like Team System than tracking source etc. - lots of good testing features, build in continuous integration etc., and all that without running through hoods in order to - well - get then an inferior product.
We encountered the same problem at my workplace a few years back when we started up our first .NET project in the midst of a bunch of RPG developers. At the time, we chose to use a separate source control system (Subversion) for anything written in .NET (or for anything else that somebody wanted to use it for). We moved all of our projects (.NET and AS/400) into Gemini for time and defect tracking purposes. Basically, we chose a single product to manage our .NET and AS/400 projects at a high level but different tools for version control, automated builds, automated testing, etc.
Years later I can happily say that this has worked out quite well for us. I really can't think of any issues this has caused - but can attest to the fact that it has avoided some potential headaches and butting of heads. I do think that you will have an easier time finding (good) .NET developers by choosing a widely used version control system. I can't speak for anyone else, but for me the use of a version control system I have never even heard of would be a bit of a red flag in an interview situation.
I have an MSDN subscription and I'm wondering what edition of Visual Studio 2008 to get. I recall reading that Team System has a lot of bonus features like doing high-level system architecture stuff, and specialized things related for doing database work. As a solo dev, I wear many hats including database developer and architect - should I use Visual Studio Team Suite to get all of these things, or are they major overkill for a single guy?
EDIT: I have a "special" MSDN license (via the MS BizSpark program for startups) that gives me access to the FULL version of Team Suite for 3 years, for myself and any developers in my startup. After that I have to pay if I want upgrades but I'm free to use it for development indefinitely if I'm okay with not upgrading (per BizSpark licensing).
With that in mind, should I look at Team Suite or stick with Pro? I don't plan to use Team Foundation Server at all.
Well, the "test" stuff is now available in "pro" (but not profiling) so that removes one major comparator. In many ways, the MSDN subscription is a bigger factor than the VS product suite, assuming you don't need the full bredth of tools.
The VS feature list here; the MSDN feature list is here.
I used to use pro, and I never felt I missed much. Of course, you could always get pro plus something like dotTrace for profiling, ReSharper for code analysis/refactoring, and maybe TestDriven.NET for testing - you'd probably still have change left over.
I now have a team suite license (which is very nice), but if I had to pay for it I'd have to think very carefully; I'd probably get developer edition + MSDN.
I'd say that VS Team System is an overkill for single developer sweatshop, but your situation may proves otherwise. Team System is great when you're working on a project where all things are Microsoft, but all the extra features (database, architect, etc) will become useless when you start working with Oracle and MySQL database. Don't put too much stress on the tools, VS Pro is good enough if you want to save money. I'd rather spend more money on extra tools such as third party component and refactoring tools than the shining VS Team System.
But, since you join the BizzSpark program, which I think is really great for startups, I think you should go and try VSTS. You basically pay nothing for the extra features. By the time you need to pay full for the licenses, I think you will gather enough experience on VSTS to decide either to stick with it, or rollback to pro.
It never hurts to have as many toys as possible in your toy box. Sure, you may only play with some of them once in a blue moon but the point is that you have them there to play with when you want to.
I run on a Mac so I have to run all of my stuff off of a VM, and I got to thinking that all I needed was VS installed and then I could use the underlying OS to handle all of my other functions (Dreamweaver, Photoshop, Office, Web Browsing) or in other words my general day to day computing life. Thanks to VMWare the transition between the VM and the host OS is easy, but you get attachments in your email that you want in you VM, or you work on a programming doc on the host os... the list goes on and on and on.
My point is this... you'll never regret putting more into your development system, you will regret not having that one tool that you wanted to have but just didn't think you'd need.
First, you should definitely use a version control product. Being able to go back in time and recall previous builds will save you tons of time and effort. Nothing worse than having it work one day, then realizing a change you made but can't remember broke everything.
Second, if it's just you (or even a couple of other people) you should probably go with subversion. Easy to setup, manage, and interact with is the name of the game here. Not to mention free, fully supported, reliable, and easy to learn.
I have recently started using VisualSVN Server and VisualSVN Client for Visual Studio. The server is free and the client is $45 for a license you can use on every one of your development machines. Add TortuousSVN and you can use the version control from the Windows shell.
I tried the TFS and VSS products from Microsoft and found subversive much easier to deal with.
If you are serious about unit testing your code (you should be) then I'd definitely recommend using the Development Edition, as it provides code coverage, which Professional Edition doesn't.
Sure, you can get most of the functionality difference between Professional & Development Edition from free/cheap 3rd party tools, but IMO these come at a price that is usually higher than what their tag says. Since you may use the even better Team Suite for 3 years I wouldn't even bother looking at the 3rd party tools.
I believe that the Team Developer Edition will now include the Database edition. This is probably all that you would require. From memory, the full Team Suite edition (Developer, Database, Architect and Test all together) is quite an expensive purchase.
One feature from team system which I like is the ability to profile the performance of your application. That might not merit an upgrade in itself if you have to pay for it, but it's very handy in some cases.
I agree with theBadDawg.
I thought it was a travesty when the unit testing features were only available in most expensive editions of Visual studio; unit testing is something everyone should have access to because it benefits us all by instilling good habits in us and helps us write far better software. Especially if we're new to the game.
Fortunately, it's now in the Pro edition.
If you can get the Team Suite and enjoy it's tools to be more productive and produce better quality software from it, do it.
I would agree with #Marc Gravell. You can probably approximate the value of Team System with add-ons, but you also need to factor in the cost of maintaining the add-ons as well. There is some pain associated with maintaining several third-party tools to get the functionality that you could get in an integrated package. Depending on who is spending the money (you or employer), the amount of pain you are willing to deal with to get all the functionality may differ.
I've been very happy with Team System, although I have added in TestDriven.Net as a test runner. We switched to this when TS came out with baked in unit testing, coverage analysis, and source code control. I'm very happy with the choice, but if I had had to pay for it personally, I probably would have gone with nUnit, nCover, SVN, etc. and kept the leftover money. I do feel that it has made me more productive, but I just wouldn't have had that much money to spend.
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.