It’s time for a big comparison: Visual Studio versus Eclipse. Given the size and complexity of the platforms, I’m only looking at certain features on which to judge these products—features I picked based on my own experience as a programmer.
Before getting into what I found, I want to go over a couple items I’ve heard from other people.
First, some folks complain that Eclipse is slow. I haven’t encountered such an issue, either on a Linux or Windows machine, and so I suspect that most of those complaints have more to do with slow systems than the software itself.
With regard to installation alone, the J2EE version of Eclipse takes about 360 MB; plus you have the JDK, which takes up 230 MB on my machine (I’m using version 7). Visual Studio 2012, by comparison, needs 2.3 GB of space with a full installation. Yes, we’re only taking about the disk space necessary for installation here—but that does give us a hint as to the sheer size difference between the products. Visual Studio also requires a working set of about 250 megabytes of memory, while Eclipse requires about 3 megabytes of memory (depending on what you’re using it for).
Microsoft’s minimum system requirements for Visual Studio say you need at least 1 GB of RAM. While that may be true, the resulting performance would be poor, to say the least. I could test it out—but frankly, I doubt any serious Visual Studio programmer would use a system with only 1 GB of RAM, so the whole “minimum requirements” thing is pretty much moot.
Another complaint I’ve heard is that Visual Studio is like the Cadillac of the development world: overpriced, with far too many useless features. I would say there’s an element of truth to this: Visual Studio is indeed expensive, if you buy the premium versions. But there are also free versions called Express, which are stripped-down versions of the premium ones. That solves the issue of cost and too many features.
First, let’s talk about usability, and let’s be frank: Neither Eclipse nor Visual Studio is a model for sound usability. They’re packed with menus and buttons and right-clicks and sub-windows. It’s very easy to get lost in them.
Eclipse, however, has a very nice organization feature called perspectives, which is a collection of windows and layout settings. You can switch between perspectives as you work on different aspects of the project. For example, there’s a perspective for Java coding, another perspective for SVN, and so on. I’ve found this feature extremely handy.
Visual Studio, by default, doesn’t offer perspectives. There is a way to import and export settings, although it’s not as useful as the perspectives in Eclipse. (There is, however, a third-party plugin that gives you perspective-style features.)
Does this matter? A lot of programmers really like switching between perspectives. I usually keep open a single perspective in Eclipse, as I don’t use it that often. So for some people, Visual Studio’s lack of a built-in perspective system isn’t a big loss—but it does point to a problem that a lot of people have with both products: Visual overload, which I discuss next.
The “Overwhelming” Argument: Too Many features
As I mentioned earlier, one complaint against Visual Studio is that it’s overwhelming, with far too many features. Let’s be blunt: yes, there are loads of features in Visual Studio, and yes, I suppose it probably is a bit overwhelming the first time you use it. But Eclipse can be overwhelming too.
These are IDEs, folks, meant for professional programmers. A good programmer should be able to get up to speed quickly enough with either IDE, and eventually become comfortable in it. It’s true that most IDEs are not exactly models for ultimate usability (not by a long shot)—but on the other hand, the tools are all there, and it’s easy to get to a particular menu and button. In light of that, argument about either one being overwhelming is simply unrealistic. Take the time to learn the tool and use the features you want. I’ve met a few programmers who get overwhelmed when trying to set up the JDK, for example, and these folks should probably consider a different profession. If there’s a feature in Visual Studio or Eclipse that I need, but rarely use, it may require a little hunting to actually find—but for most of the time, people tend to stick to the same collection of tools.
The Real Power: Customizability
Let’s not lose sight of what Eclipse really is: An extensible, general-purpose IDE. It was built from the ground up to work with pretty much any decent build system, and to support pretty much any programming language. And right from the beginning, it’s been very easy to write extensions to Eclipse.
But wait! Visual Studio is also extensible. Years ago I even wrote a book about Visual Studio extensions. (The book is now severely outdated.) There are thousands of community add-ins available via Visual Studio’s built-in package manager, as well as through an enhanced manager called NuGet. (According to nuget.org, there are over 14,000 unique packages available for download.) Making it easy to enhance Visual Studio and actually build up a community around the extensions has been one of Microsoft’s goals for quite some time.
But there’s still a bit of a difference. Eclipse is built as an IDE, and no more. The languages and compilers it supports are extensions to it. While there actually is a version of Visual Studio available that’s just the IDE, which is a starting point for development in other languages (whereby you would customize Visual Studio to support those other languages), the reality is that Visual Studio is marketed and focused on two primary areas: Windows desktop development, and Web development using C# or Visual Basic. You can start with the barebones IDE and build a development system for any language and platform you like (in theory); and yes, there are other languages available for Visual Studio (node.js, IronPython, and F# are three examples)—but compare that to the offerings from Eclipse, where right away there are many platforms and languages available from the main download page, without having to install extensions. Furthermore, each download is a configuration of Eclipse packaged with the extensions already installed. For example, there’s one specifically for Java EE development, one for C/C++ development, and one specifically for UML modeling. (There are more as well, available from separate Eclipse project pages; for example, if you head over Eclipse’s PHP project, there’s a link that takes you to zend.com, where you can download Eclipse set up for PHP development.)
That’s where Eclipse shines. It’s an open-source project, so anyone is free to take the software and customize and repackage it for a specific platform and environment—and indeed, many groups have done just that. Want an Eclipse set up specifically for Scala, for example? Head over to scala-ide.org.
While you can get Visual Studio set up to work with other languages, Microsoft hasn’t gone very far to actually market it that way. Many people have tried to adjust the platform at different times, but the projects eventually get abandoned. And if you do find a Visual Studio extension for a language, you need to be careful about the target platform. For quite some time, somebody was working on an extension that let you develop Scala software in Visual Studio. However, there was a catch: The compiled code targeted the .NET runtime, not the Java Virtual Machine. While technically Scala is just a language and not a full platform, most people who develop in it probably expect to target the JVM.
As such, if somebody needs to develop for these other languages, they’re far less likely to even think of Visual Studio. Which brings us to another huge point: Visual Studio only runs on Windows. If you’re using Linux, then it’s not even an option. So, are we really comparing apples to oranges here?
Wait, Apples and Oranges?
In one sense, we may well be. I was recently hired to create an Android application written in Java. Visual Studio wasn’t even an option, but Eclipse was on the table. That being said, I don’t think we’re totally comparing apples to oranges: We have two powerful IDEs here, each with features that have found their way into the other platform.
The Heart of the IDE: Coding
Everything else aside, let’s not lose sight of the real purpose of Eclipse and Visual Studio: To write code and build software. The bigger software companies have a separate build group that runs scripts that periodically (typically every night) pull the latest source tree from source control, followed by a full build. This build process operates independently of the IDE and relies on various make-style tools, whether it’s the classic Make, or something like Ant, or one of the newer alternatives such as Gradle. The IDE really doesn’t play a role in those cases. Some smaller shops might use the IDE to do their builds, but my main point is that the real meat of the IDE is for writing code. (You may disagree, of course.)
Thus, we’ve seen lots of tools to help with the creation of code. In addition to syntax highlighting (which has existed for a couple decades in code editors), Eclipse and Visual Studio have various auto-complete tools, such as Microsoft’s Intellisense, that are supposed to make code creation faster and less error-prone. (For example, Intellisense will correct the casing of a function name, thus preventing a compiler error.) Visual Studio, when used for C# programming (for example) can add the correct using statement at the top of the source file if you use a class whose assembly is loaded into the project. Eclipse, similarly, can add import statements automatically for Java programmers. And there are different features in both, such as one that will tell you function parameters when you’re typing a function, and so on. Both Visual Studio and Eclipse do quite well at these, and even seem to have “borrowed” ideas from each other.
Visual Studio, unfortunately, has some problems here. I already mentioned that there are a lot of abandoned projects in the ecosystem. Many have also succeeded, but not without some problems. Case in point: I do a lot of multi-core programming for a certain client of mine, and I make heavy use of Intel’s Cilk Plus extensions to C++. Intel has integrated their Cilk Plus/C++ compiler into Visual Studio, along with numerous tools to help in the development of multicore and vectorized programming. The tool is called Parallel Studio, and it exists in part as an enormous add-in to Visual Studio. The developers at Intel spent a great amount of time building this, and the integration with Visual Studio is tight. Except there’s a problem; the editor doesn’t recognize the Cilk Plus extensions. There are some ways to trick the Intellisense to recognize some of the extensions (such as the new keywords), but it totally chokes on the extensions to the syntax, such as a special array notation that looks similar to Python array slices.
People have complained to both Intel and Microsoft about this problem. Intel says their hands are tied, because while Microsoft gives add-in developers the ability to add support to new languages, they don’t provide support for modifying the existing languages. It would be nice if there were some XML file somewhere that could be modified, or even a code library that could be written and tacked on, but it can’t be done (alas!): we’re stuck with Intellisense not understanding the extensions. So people have taken it up with Microsoft, complaining that Intel’s product doesn’t work right. Microsoft says it’s not their problem, and so the problem doesn’t get fixed.
Now compare this to Eclipse. First, because the product is completely open source, it would be possible for anyone with the time and effort to modify it. But because it’s built for extensibility, it wouldn’t really even be necessary to modify the core product. You could instead create a new extension that understands the Cilk Plus extensions, or start with the existing C++ extensions and create a new fork that handles Cilk Plus (or any other changes to a language).
Ultimately, one could argue that the Intellisense errors aren’t vital, and we can just ignore them, or turn the Intellisense error-checking mechanism off altogether. But I want to use Intellisense because it can find actual mistakes. I look at the error list, and every time I skip over the same old ones about the Cilk Plus extensions. It’s a hassle, and the whole point of the IDE is to simplify my work and make me more productive.
Yes, You Really Can Do That in Visual Studio (Sorta)
Although I pointed out a shortcoming in the Cilk Plus plugins, Visual Studio really is extensible; and in many cases, you can do many of the same things as in Eclipse. For example, Eclipse has a lot of cloud-programming support tools. I’ve used many of these, and typically they involve additional windows in the IDE, such as the output from a remote server, or even a complete command-line interface for configuring servers.
Some people are surprised to learn that you can also extend Visual Studio with new windows such as those I just described. It’s all there, and you can code your extensions to communicate with remote servers and display the output as text in a new window that you define. The coding of such windows isn’t always easy, but it can be done.
However, something recently happened with Visual Studio. Until VS 2010, there was a complete Macro IDE where you could easily automate Visual Studio with macros. This was an extra way to automate Visual Studio separately from the creation of plugins; you could create plugins and macros. Plugins are usually written in C++ and compiled down and integrated into the IDE.
The macros, however, were written in Microsoft’s own Visual Basic language. You could record keystrokes, for example, and save them to a macro that you could then replay at any time, either through a keyboard shortcut, a menu item, or a button. And if you wanted to change the macros, you could open them up in the Macro IDE. This was a full, separate IDE built on the same base IDE as Visual Studio itself.
And then, for some reason, Microsoft decided to get rid of the macros (but not the plugins) in Visual Studio 2012. This has frustrated a lot of programmers.
The macro system used an exposed Object Linking and Embedding automation object. If you’re really determined, you could write a system under the Windows Script Host (WSH), grab a Visual Studio object, and have at it. But most developers may have to resort to external tools in order to get parts of their workload done—I would say that’s a mark against Visual Studio.
In preparation for this article, I spoke to a few other programmers, and those that like to brag about productivity usually talk about automating the editors to enter code snippets for them. One full-time Java programmer told me that he hasn’t had to manually type in any setters and getters in years, and he has a template from which all his objects are typed in automatically, thanks to the code snippet tools in his favorite editor (which isn’t Eclipse—he uses IntelliJ). Clearly, methods of automated typing seem to be a favorite among a lot of programmers. So why did Visual Studio remove a feature that facilitated this? Who knows.
But what about Eclipse? Eclipse has a very handy code-snippets view that I like to use. There isn’t built-in macro support, but there are a few addins that provide it.
Eclipse seems to work a little better with the different make tools, although Visual Studio is perfectly willing to call an external make tool and report the results in a code window. Even so, Eclipse was built to handle external make tools a bit more easily—after all it’s an open and extendible IDE that can work with nearly any language and build system, whereas Visual Studio isn’t.
Visual Studio has evolved from its early days of being an IDE for the old Visual C++ compiler, after which Microsoft reworked it to also support Visual Basic and FoxPro. It wasn’t originally built as an all-purpose IDE. And some might say that’s a major mark against Visual Studio.
Some days, I find just having a code editor and a make tool are good enough, and I wonder if the IDEs really are helping us that much. Some aficionados of data-modeling tools rely on Visual Studio (or the UML tools in Eclipse), but I’ve found Visual Studio’s “Code First” approach to data modeling to be lacking in advanced data modeling features, for example, and is best suited for smaller applications. Nor am I particularly thrilled with the UML tools in Eclipse. How many developers and programmers actually use the extra tools built into Visual Studio or available as plugins for Eclipse?
Indeed, some of the standalone code editors offer auto-complete and all those handy code productivity tools, which allow plenty of professional developers to skip IDEs altogether.
Bottom line: a developer with sufficient skills can be productive in both Visual Studio and Eclipse, although each platform has its own aggravations. But in the end, both can get the job done.