Visual Studio vs. Eclipse: A Programmer’s Matchup

Visual Studio.

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.

Usability: Perspectives

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.

But what if you want to work with a new language or extend an existing language? Eclipse makes it very easy to write your own plugins. For example, there’s an Eclipse project that adds JavaScript support to the code editors.

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.

Conclusion

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.

 

Image: Microsoft

Comments

  1. BY mojmir says:

    I am working with both – VS and Eclipse. Or, more accurate information is: I dropped Eclipse and went for IntelliJ IDEA for Java project.

    In my eyes is VS is much more powerful tool compared to all other Java IDEs what I had.
    For me are NetBeans and Eclipse the worst IDEs on the world compared to any other languages so only salvation for Java language is IntelliJ.

    I will not compare the installation size between one IDE or another. Who cares about those parameters anymore? No one!
    In current world and global world economy is there only one attribute important for survive. It’s speed! The speed of development!
    When I compare this attribute then I have to compare languages! C# vs. Java and C# wins 10 times better!

    I am able to create application in C# and VS 10 times faster (maybe more) compared to all Java IDEs.

    How is this possible?

    Because C#, .NET and VS is one compatible ecosystem and it’s standardized. And that is huge advantage!

    Because in .NET is all working well. In Java you have deal every day with some issue or crash or something else.

    In Java you have tons of different solutions and most of them live no longer just couple of years and than they are dead. You have tu go for change. I never experienced this in .NET world.
    Next reason is compatibility.
    When I have to run my applications on Linux I have more success with .NET compared to Java.
    Why?

    Because Java is not Open Source anymore and Linux distributions put it away from native support so u have to take OpenJDK instead.

    At the other hand .NET 4.0 or 4.5 (don’t; remember right now) is supported by Wine and the .NET applications run perfectly. You don’t have Silverlight or WPF on Linux ofc, but you have at least robust foundation.
    With Java SE you have even less. Java is good on Linux only in EE version.

    Next – compatibility on iOS and Android.

    With C# you can develop apps for all platforms. There is Xamarin! Big winner!
    With Xamarin you have much more better support on iOS compared to JavaFX fo example. Who knows if JavaFX someday will be on iOS officially. Not in next few years. There are some apps here running JavaFX on iOS but they are unofficial and unsupported by Apple. So you have a big problem! You have only one support for iOS – is RoboVM and is much more worst compared to Xamarin.

    Android – Google dropped Eclipse and have created theyr own IDE. Maybe he is working on new programming language too. Seems that way.
    And Java is old as a language. In C# you are much more faster than in Java. Java 8 has lambdas finally … hallelujah – after 10 years after C#.
    C# has native OOP support for events. Java has not. “Event” support in Java is nightmare.
    .NET has reflection and serialization which is working. Serialization and reflection in Java is irony.

    And look at project /packages / management at VS and all Java IDES. VS is best. No problem at all. But all Java IDEs has terrible project management.

    Customization is power in Eclipse only from one reason. Without it is Eclipse useless. But VS do
    not need so many plugins because just don’t need. And VS has even better market place for addons what Java world copied from them.

    So … that’s are powerful attributes why is VS better. And they are not all of them.

  2. BY Anil says:

    NuGet packages are not extensions and are not used to “enhance Visual Studio”.

  3. BY Rob S says:

    As implied in the comments, one of the key parts missing in your comparison is the application presentation layer.
    In many cases, building an application is back-end processing (like on a web server or building packages that other pieces can use.)
    In these cases, Eclipse is probably a tiny bit better than VS, although VS holds its own pretty well too.

    Where the real power of VS comes in for C# and so much more so for VB is the GUI layer. It’s so easy to build a working app in seconds in VS. Open an Application project, drag-drop a button on the form, change the Text property to Close, double-click the button in the GUI, enter Close in the code block created for you and run. Instant app! (The closes I saw to this in the non-MS world is with Visual Cafe, which had a very similar GUI for Java, but Borland eventually bought it and shelved it.)

    Obviously, as you start working your app, you’ll spend a lot of time on the front-end form for a while at the beginning, but then all the rest of the work goes into the code behind the scenes.

    Who’s the winner?
    For front-end processing, VS wins hands down.
    For back-end processing, I’d lean toward Eclipse.

  4. BY Rob S says:

    (subscribing)

  5. BY Borook says:

    As a long time VS user who was recently forced to switch to Java and therefore Eclipse let me just say that VS is WAY more polished and easier to work with. Intellisense, Visualization for debugging, debugging in general, code collapsing(!). Everything in Eclipse so far is sort of close but not nearly as good. I’m coming from C# so it not the transition to Java that is hard its trying to do things that were easy and intuitive in Eclipse that just don’t measure up

    • BY RobS says:

      As I continue to work, I see that there are a few nice features in Eclipse, like being able to rename variables on the fly and see them all update as you type, and the ability to see a set of all matching items (search text, variables, function/method references) etc and being able to get to them on a single click.
      However, VS still makes it easier to work with the debugger, where breakpoints are set with a single click, very easy to split a window with a simple drag on the scroll bar (top or side) and bookmarking items.

      I know the customization of Eclipse is very powerful, but it’s maybe too much and confuses me when it switches contexts unexpectedly like when it stops on a breakpoint and wants to jump to a new perspective where all the pieces are set up differently (unless I re-synchronize them.)

  6. BY Mawe says:

    You wrote that VS doesn’t have code snippets. That’s simply not true. They have always been there in VS.net. It may be that they have been introduced for C# a few years later than for VB, because the IDE for VB has always been more advanced than the one for C#.
    Just make a right-click somewhere in the code window and select “Insert snipped” (or hit ctrl-KX) and an intellisense-like menu pops up with lots of snippets. Theres a snippet manager in the tools menu where you can load custom snippets.
    After a snippet is inserted you can change the default variable names. If a name occurs several times within the snippet you only have to edit one, and the others are synchronized.

Post a Comment

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>