So here's the deal.

First off, Im in love with Eclipse. It's awesome. Eclipse is open source software, and it's also free.

The deal with studio, is that like eclipse.. it's plugin based, and most, if not all of the stuff you're talking about here is availiable as a third party plug in. The only catch is that you need to pay for it.

However.....

"Based on the TortoiseCVS code, a plugin for Microsoft's SCC API (allowing access to CVS from within Visual Studio and other IDEs) is being developed. Read more here: http://sourceforge.net/projects/cvssccplugin/"

hehe. I'm gonna go through these 1 by one just for fun...

1. Yes, C# is an M$ implementation, but there are a few key differences. C# is easy and straigh forward. You can sit down and spew out something fairly complicated in half an hour as opposed to having to plan things out with java and end up spending the a good portion of your time refactoring the code so everything works together... (take the example of your and Karen's Security lab development time vs ours (which was done in about two hours, not counting that Big-Integer thing..) ).

2. There are refactoring tools available for VS.Net. Nothing free (yet), but they're in development. The promising seems to be C# Refactory (http://www.xtreme-simplicity.net/CSharpRefactory.html).. I've been watching this for a few months now..)

3. hmm. I haven't noticed any problems with the indenting.. could be I'm more used to it though since I prefer VS.Net over Eclipse.

4. See 3. :) If I could be bothered, I'd turn this off in Eclipse since I'm more used to doing it myself anyways.

5. I agree with you completely. This my major pet-peeve as far as VS.Net goes.

6. http://sourceforge.net/projects/nunitaddin/
NUnit-Addin >> NUnit Gui. :)

7. It's a Microsoft product, did you honestly expect them to pay developers to get it their star dev-app to work with a FREE alternative to SourceSafe?
If you're really desperate TortoiseCVS is a perfectly acceptable alternative.

ugh. Guess I oughta start using the Preview button eh?

Thanks for the comments -- I'll try that stuff out.

Yeah, the NUnit-Addin really makes it alot easier to unit-test with VS.Net.

Plus it works with NUnitASP too which is really good.

There's also the CSUnit Framework that you can look at, which integrates itself into VS.Net too.

CSUnit seems to be under more rapid development than NUnit, but I just prefer NUnit (mostly because of NUnitASP, which you can't get for CSUnit).

Yeah, I'm trying to get out of the "web applications" area ... so no ASP for me.

you should see the really powerful refactoring tools we have in smalltalk:

http://www.refactory.com/RefactoringBrowser/Rewrite.html

If you have to switch between apps and it takes 5 seconds, you DEFINITELY need a faster machine. Realizing that 5 seconds as proof that Java is not suitable for desktop apps (Eclipse) would be nice too.

That "5 seconds", which referred to switching there and back and also includes the time it takes your brain to context switch from one app to another. It doesn't really have anything to do with the computer's speed.

I disagree. Java is definitely suitable for desktop applications and Eclipse is proof. Don't be surprised if more Java/SWT/JFace applications are made in the next year.

I wont be surprised if more Java/SWT/JFace applications are made in the next year. I will be surprised if any of them are finished next year. Eclipse is flakey as hell on linux, and slow as hell on windows.

Eclipse isn't any slower than another other Windows application I run. Of course I have a half gig of RAM. A development machine should have a certain about of horsepower and memory -- we can't hold onto our old machines forever.

This is a very interesting topic, and I would like to see it continue. I have worked extensively with both Visual Studio .Net and Eclipse on many different projects.

The differences I have found with with these two platforms flows all the way back to the differing philosphies I have found with Java developers and .Net developers. From my point of view here is how I see the two platforms:

Eclipse:

A very powerful, and extensible platform geared towards software engineers. I use the term software engineer as someone who understands to art of creating software, software process models, software frameworks, architectures, practices, etc. This tool is second to none in terms of software engineering features, such as refactoring, unit testing, build/deployment. I have found that the people who regularly use this environment have a very good understanding of software development/engineering. They are more concerned about having tools that make their life easier while producing higher quality code, than having a tool that builds applications for them.

Visual Studio .Net:

A very structured rapid application development environment geared towards software developers concerned with creating business applications. I define a software developer as someone who develops software applications. While many .Net developers I have worked with talk about and understand software engineering concepts and theories, they very rarely use them while building applications. In my opinion Microsoft has geared this platform more towards a general developer more concerned with business logic and data flow. Visual Studio .Net makes things too simple in my opinion. They also do not include any of the advanced and useful software engineering features found in eclipse. The danger in making things too simple, rapid, and for the general public is that many developers who could be excellent software engineers choose to be lazy due to the environments seemingly encouragement to do things quickly without much thought and engineering.

While both can be used very effectively by any level of developer. I have seen a very distinct difference in the people and mindsets that use these two technologies. I would love to hear if others have had similar or differing experiences to mine.

By the way, I prefer Eclipse, and find myself becoming very frustated while dealing with the inherit stupidity of Visual Studio .Net on a daily basis.

I'm getting this impression too, Justin. I think we are reaching a tipping point of complexity though.

Software is getting too complex to "RAD" or hack together. Tools are going to rule software engineering in the future -- tools that make it easy to develop and modify your code without compromizing quality too much. Quality will effect development times enough that people will pay more attention to it, and they'll demand tools. Developers spend far too much time fixing bugs and regressions.

I agree with your assessment of the Eclipse vs. VS.NET mindset. I think the software engineers will win in the long run -- and they'll use the best tools for the job. Right now, Eclipse is winning IMO.

Some excellent points Justin. I think this is absolutely the state of play with regards to the mindset of the average professional working with the two platforms, currently.

However, VS.NET and its previous versions have always been hugely productive in my opinion - more so than any IDE I have used so far (although IntelliJ Idea is nice). This doesnt necessarily mean that the quality of software produced decreases though - as long as the engineer/developer(!) is competent. Your suggestion is almost that if VS did less, and was less accessible, then its users would be forced to work harder; and this in turn would somehow produce higher quality software?

I found it a huge shock using Eclipse for the first time after several years using VS. The features are mostly all there in Eclipse, but the entire code-compile-run cycle is way way way slower for a start. I guess I'm a little stuck in my ways, but really dont see a more productive platform to develop on than .NET using VS right now.

Chris

To me the primary benefit of Eclipse is that there is no compile step. All code is compiled as you type, and when you save a file, one of the docked panes is filled with the syntax errors throughout your project. (So, it compiles the current file in the background, and compiles all the other files in your project when you save. )

Given a suitable development machine, all of this happens relatively instantly, and the IDE feels just as fast as VS.NET 2003 on my machine.

Eclipse also has Refactoring support, better code completion, and better unit test integration, although that's a little buggy. (The JUnit pane often wants to pop up even though there are no errors.) NUnit GUI is too intrusive, but I haven't tried CSUnit.

However, to be fair, C# is not the best coding tool in VS2003. As an experiment, I recently ported a relatively small Java application to VS2003, and gave up using C# due to the poor IDE. Instead I ported everything using VB.NET, which is a much better tool. It does syntax checking on the fly, much like Eclipse/Java, but not quite as powerful. It also supports much better code completion, and in a lot of ways is even better than Eclipse/Java. For example, it automatically handles indenting correctly in many cases, even when cutting/pasting code. I found several bugs in this area, but in general it's pretty even with Eclipse/Java.

In my mind the IDE and Language must be evaluated together when discussed in the context of modern software engineering. Those of us who have used modern tools do not want to go back to the dark ages.

Here's how I rank the Java-like language combinations I've used, on a scale of 1-10
Java 7
w/IntelliJ 9
w/Eclipse 9
w/Emacs 3
C# 8
w/VS2003 4
VB.NET 8
w/VS2003 8

Still, objectively there were quite a few things I liked better about using VB.NET than Java/Eclipse, and overall I prefer Java/Eclipse over Java/IntelliJ, despite the latters better feature set. And none of the Java tools have the true equivalent of Visual Studios Macros/Addins.

I do have hopes that Whidbey will address the problems with the VS tools. Due to their track record, I have the best hopes for the VB team. It also sounds like both .net languages will be greatly improved, although I feel they both already improve on Java.

I think eclipse is designed for people who is developing huge applications for enterprises. It is extremely complicated for normal use.

I think one may prefer eclipse over vs.net if he is developing a very huge program and needs to use features that exist only on the eclipse.

Also idiots who pretend to be smart by thinking that they should be smart because they use a complicated developer tool can also prefer eclipse over vs.net, but because eclipse will make you less productive, for most of the developers I recommend vs.net. Visual studio is natural and easy to understand. You don't need to learn a whole new set of concepts and you don't need to read a whole book just to understand how the editor works. If you are an idiot and want to learn a complicated tool, I recommend emacs, instead of eclipse. Just call everything else stupid and show your inherent stupidity in you. Some idiots also use vi and claim that vi is the best development IDE out there. If you are stupid there are various tools out there for you, but if you are smart you choice is easy. :))

Jin needs to be more tolerant of others. The idea that Eclipse is for 'software engineers' while VS is for 'developers' is apt. In my 47 yr old opinion, this accurately reflects the long standing difference in focus between the Unix and Windows worlds.

My question is how long can MS hold out against free software? Eclipse will surely evolve to provide the kinds of business software tooling at the center of VB and VS. And then what? It's not just us grunts who will be looking long and hard at the cost of VS. Consider General Electric which (I am told) recently handed down a policy that all business software developed for Windows was to be replaced ASAP for cost reasons.

What is that cost reason? Visual C# costs 109$, a 1 day salary in USA. I would understand that in Romania, where that is a salary for 1 month, but not in the USA. In USA in 1 year of use if the productivity gain is even 1% it worths the price. In Romania the variants like Delphi with its 2500$ and Idea with 500$ are there from start excluded. To buy a Delphi you have to give all your salary for 2 years, in wich a new version will appear.

I agree, the cost issue is minor.

That $109 figure is unrealistic, IMO. MS is great at getting you in cheap and then upgrading you to an expensive suite of software, like the 'architect' version ($2500?). Plus, their tools 'work best' with a whole bunch of other very expensive products like SQLServer. But that's beside the point. A 1% or even a 10% gain in productivity is not enough when 10 years from now your code all has to be rewritten into another language so it can run on an open platform that the industry has standardized on (open meaning vendors provide competing impls). MS knows this. They do everything they can to fragment the market and prevent standardization (like offer 4 programming languages that all do the same thing and require complicated proprietary tools like VS). So long as developers look only at their current project, and split hairs over minor and fleeting productivity gains, the strategy works. But eventually, the advantage of MS's tools gets so small (compared to something like Eclipse), that corporate America wises up and we reach a 'tipping point'. The GE decision suggests to me that we're getting close.

So here it is, January 2005, and you know what? VS has the SAME problems that it did when this thread was started in 2003. Meanwhile, Eclipse has gone through a number of releases and its performance has improved (so those earlier comments about performance probably no longer hold true).

Recently, I had to take over some code that was written in C#. As a language, I think that C# is pretty cool, so I was excited to take on the project. However, once I started to work on the code base, I realized how irritating VS is compated to Eclipse, basically for the EXACT reasons that Ryan listed two years ago.

So you know what I did? I got Eclipse 3.1m4 (since it's the only release that is Java 1.5 compatible at the moment) and copied all of the C# code in there and just started translating C# to Java. This may sound a little ridiculous, but it has worked beautifully! With Java 1.5, you have generics, autoboxing, varargs, enums, etc., so it really is the same as C# and translation is not that difficult. More importantly, I was able to reduce the size of the codebase because the C# developers had to write a new class "FooCollection : CollectionBase" for every Foo for which they needed a typesafe collection whereas I could just write "Collection<Foo>" in Java 1.5 and avoid creating a new class explicitly.

Honestly, I really tried to use VS before deciding to do the translation. I installed NUnit, but it's not as clear when your tests pass or fail and you can't click on the stack trace to jump to your error to correct it. (I installed the NUnit-addin: http://www.mutantdesign.co.uk/nunit-addin/ because I didn't want to leave the window to run my tests, but it wasn't close to Eclipse's JUnit integration.)

I also tried installing TortoiseCVS, TortoiseSVN, and igloo. I couldn't get igloo to work at all, and the Tortoise brothers require you to leave the VS window to make changes to the repository, so this was another bust. I eventually went with this thing called Ankh which provides SVN integration right in VS, but it's nowhere NEAR the CVS support you get in Eclipse because you can't move files around and have the version-control tool handle all of the communication with the repository like it should.

The only snag in moving from VS to Eclipse was that VS had seamless support for web services -- you would add the WSDL to VS as a web service and somehow you could magically start referencing the classes in your project. In Java, I had to get Apache Axis http://ws.apache.org/axis/ and run WSDL2Java to generate all the Java class files and paste them into my new Eclipse project. Not such a big deal, but certainly not very obvious if you didn't know about Apache Axis (which few do, unfortunately).

Like Ryan mentioned earlier in this thread, you lose your whole train of thought when you switch windows (for either the NUnit GUI or TortoiseCVS). What's even worse is having to run a full build to find out that you forgot a semicolon -- like switching windows, running a build in VS is really distracting because all that text goes running by and you can't ignore it even though most of the text there is worthless -- my eyes just can't ignore the movement, I swear!

I sincerely hope that VS 2005 addresses many of these issues, but my project is due in a few weeks, so I can't wait that long. So please, as someone who really tried installing the VS plugins, let's be clear -- it's not as good as Eclipse. Translating all of your code to Java is pretty extreme, I admit, but with 1.5, it's really not so hard. Use Apache Axis to get support for web services and SWT to talk to ActiveX objects (like the Microsoft Office applications) and you're pretty much on the same playing field.

Now you just have the right tools.

This is great and reflects my experiences precisely. Here's a blog about the Visual Studio presention given by Microsoft at Eclipse Con 2005: http://benjaminbooth.typepad.com/tableorbooth/2005/03/eclipse_con_200_1.html