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, 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, 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

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.


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.

Upload Your ResumeEmployers want candidates like you. Upload your resume. Show them you’re awesome.

Image: Microsoft

21 Responses to “Visual Studio vs. Eclipse: A Programmer’s Matchup”

  1. mojmir

    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.

    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. Rob S

    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.

  3. Borook

    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

    • 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.)

  4. You wrote that VS doesn’t have code snippets. That’s simply not true. They have always been there in 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.

  5. Bryson

    You only use one perspective in eclipse? Do you ever debug your code???

    There is one topic you are missing COMPLETELY. You CANNOT develop VB6 applications in Windows 7 and beyond! You can certainly run VB6 applications, but if you want to develop or modify, you are going to have to program in Windows XP. Last time I checked, Windows XP is NO LONGER supported by Microsoft.

    If you are overwhelmed by the features an IDE provides for you then you need to find a new profession. Or just use notepad. Also Eclipse is free. Visual Studio has many different levels. Reading over the differences you find Visual Studio (IMO at the moment) is a much stronger IDE than Eclipse developing Java. This is only for the Ultimate version of Visual Studio when I say this. My work only uses the free Express version so we’re screwed of all the great things we could have which come free with Eclipse.This is tongue-in-cheek, but I’m not sure how well the svn/repository is in Visual Studio so that’s one area I’m unaware of.

    Intellisense is a whore. Yep. It truly, truly is. It wants to rewrite my code, format my capitalization, and try to guess what I’m about to type after typing only one letter. Let me type and format my code the way I want to. I currently have it off and only use it when I need it by using CTRL+j.

    The debugger sucks as well. Running your code and watching it stop at a break point. Click next and BOOM it will run the program and not go the next line you wanted it to. Very clumsy. Let’s not even get started on the fact if you build your solution or run in debug mode, upon completion of your build or after exiting your app in debug you may have to close Visual Studio because there is an instance of your program or build still existing. Maybe it’s the fact I’m using the Express version. Maybe it’s the fact I’m running on 32-bit Windows XP Professional. Either way, it’s unacceptable.

    It is nice of Microsoft to provide a free version of VS. You won’t be able to download any extensions like you can easily do in Eclipse (which is always free). You also won’t be able to even test your code in VS Express, which is very essential to a beginner programmer.

    I feel this comes down to what language you are developing for. For .NET, C#, or even C++ go ahead and use Visual Studio. There isn’t a .NET version of Eclipse so there you go. Any other language? Eclipse, IntelliJ (never used it), or any of the other language specific Eclipse spin-off is your sweet ticket.

    • Whew! A few shortcomings here in your response. You must be primarily an Eclipse developer so you’re not too familiar with the VS environment.

      1) You can create VB6 code in Windows 7, at least inside MS Office. I think you meant that you can’t create a stand-alone project using VB6. I haven’t tried that yet but suspect you’re right.

      2) “Windows XP is NO LONGER supported by Microsoft.” That is correct but it doesn’t mean you can’t continue to developer using that platform. Of course, your audience will diminish if the app doesn’t work beyond XP.

      3) “Intellisense is a whore. Yep. It truly, truly is. It wants to rewrite my code, format my capitalization” The only time it changes capitalization is if your definitions are capitalized or you have multiple definitions and the first one is capitalized. For example, in C#.Net, if you enter this.close(), that is invalid but intellisense will fix it as this.Close() so you didn’t have to push the shift button. One less thing to fix!

      3b) In addition, the intellisense has gotten smarter. In the newer versions it typically shows you the most recent selection, which turns out to be the correct choice much of the time. It also now searched for anything that “contains” the text you type (whereas Eclipse only shows you things that START with what you type, meaning it’s impossible in eclipse to find “myMethod” by typing the word “Method” but it appears in the VS IDE) I hope that shows up in Eclipse soon.

      4) “The debugger sucks as well. Running your code and watching it stop at a break point. Click next and BOOM it will run the program ” You must be pushing the wrong button. If you click the “go” button (green triangle / F5) you’re telling it to resume running the program. If you use the step-into or step-over buttons, then it will either step into sub code or run a single line. If not, you may have other events interrupting your code flow.

      5) “upon completion of your build or after exiting your app in debug you may have to close Visual Studio because there is an instance of your program or build still existing.” I know there’s a bug that has been around for a few versions that MS has yet to fix. Annoying but no more annoying that some of the bugs I’ve found in Eclipse that I don’t have time to fix and sit there bugging me every few days.

      6) “You also won’t be able to even test your code in VS Express” Not sure what you mean since I use VB express and C# express and can easily set breakpoints, step through code very simply and even set conditional breakpoints and even assertions to interrupt the code. Eclipse has these too, but I find them a bit trickier in Eclipse (although still fully functional.)

      7) “I feel this comes down to what language you are developing for. For .NET, C#, or even C++ go ahead and use Visual Studio. There isn’t a .NET version of Eclipse so there you go. Any other language? Eclipse, IntelliJ” Good conclusion. For Windows, use .NET; for java-based projects, use something else.

      • You are right. I’ve only started developing in VS since late May.

        All numbers are related to your numbers in your response so some of them are skipped:

        1) I was referring to projects. Hopefully, Mawe’s comment is true!

        2) You are correct and I agree.

        3) I agree again. My main issue with it is that it pops up all the time trying to guess what I’m typing. From variables to whatever. Just stop please. I’ve turned it off and only reference it when I need to using a shortcut.

        3b) That search feature is nice.

        4) No, it’s not me just pressing the wrong button. It does continue running the program after I hit a break point and click ‘Next’. Only sometimes though.

        6) I meant TDD. Like any one of the testing plugins you can download and use in VS or JUnit tests in Eclipse.

  6. Bryson and Rob, you can still install Visual Studio 6 on Windows 7 and use it to develop VB6 executables. However, you have to turn Aero Glass off to avoid a strange performance issue in the form designer. And there are some glitches during the installation of VS6 I don’t remember exactly. As far as I recall you have to run the setup as admin or in WinXP compatibility mode or something like that. I haven’t tried it with Win 8 so far, but i don’t expect further problems.

  7. arithmeticbird

    1) Perspective is one thing which Eclipse users thinks as a feature. But I am not buying this. Intellj and VS are switching UI according to context and it is more intuitive and faster.

    2) If there is one thing where eclipse wins is refactoring support. You can have the same feature set with ReSgarper installed in VS.

    3) Debugging is the *killer* feature for VS. I am yet to see an IDE which has better support for debugging than VS.

    4) Android development in Visual Stdio is available with Xamarin plugin. You can use c# to create android app. Comparing with eclipse in this area is unfair. I can say the same thing for eclipse regarding ios development.

    For me The best IDE for JVM is IntelliJ Idea and for windows VS + Resharper

  8. Tapatio

    I was the last 4 years in 2 companies working in java projects. The first one, used net beans. Really nice IDE but heavy in resources.
    The second one , full eclipse. Shit man !! You can make any detailed comparisons you want but for me, the overall, is a heavy tool that eats many resources and sometimes is slow, because is built on top of java. It crash any time, and you have to tweak an army of configurations and settings to do the things work. Don’t mention the several times it crashes. It’s not for nothing that this site exists.

    Now I’m in a company working with full c# projects. What a relief ! I’m Visual Studio 2013, and even if it isn’t perfect, it start fast and the least thing I have to worry is problems of the tools. Almost everything work smooth. I’m glad I left off the java environment.

  9. Im comming here looking to switch from VS2012 to eclipse. I was working eclipse cca 6 years before (java). Now I do C++ again for very complex project. And I’m very frustrated with VS. Really slow, unstable – often shows window “VS is busy”. …. this could cause TFS (MS Team) – maybe without it could be much better… but TFS is also Microsoft product it should perfectly collaborate. Instability of eclipse could be usually if you use many 3rd party plugins. After I reduced unnecessary plugins, Eclipse works stable. I liked that java dev with Ecl. is really fast, convenient – for coding, analysis, debugging, tests.
    Many complaints to Eclipse I see here seems to me from people which do not really know Eclipse (inexperienced user) (if somebody complains to intellisense, debugging, code collapsing, setting breakpoints…… In my experience also these are done BETTER be Eclipse than VS. ).

  10. I cant believe that any programmer that has used Eclipse could imagine the piece of crap that Visual Studio is ….
    Visual Studio was OK … back in the 90s before Eclipse … but in the short time that Eclipse has been around it has demonstrated itself as the most superior IDE ever.
    Anyone who has to go back and try and debug using Visual Studio is in for a big disappointment .. Visual Studio has not evolved at all since then , barely.

    Unbelievable when you hear VS die-hard’s trying to defend ENC (edit and continue) … compared with what you can do within Eclipse …. and refactoring in VS barely exists …. And the terrible integration of Source Control … TFS .. also a piece of crap ….
    oh me oh my ….. the saddest part is that I have to continue to use this because my ignorant boss listens to his ignorant boss who insists that we become an MicroSoft VS shop …..

  11. Stanley Gillmer

    I only just started again with Java development for Android and so after searching the web for a good IDE decided to go with Android Studio which I had a terrible time to install. “Gradle” was the culprit and I gave up and tried the second best thing according to some sites called Eclipse. Before I give my opinion, some background.

    I come from Visual Studio. I started back in the day with Visual Basic 4 and loved the IDE. after every update the IDE got better until MS went the dot net route. the IDE was crap. It was slow. the things I loved in VB6 weren’t there. I could scroll the code page with my mouse that I loved but further on I didn’t like it. I had to stick with it because my company are partners with MS and we do Windows development. I am glad I did though. VS blossomed in this high flying, fast moving, sexy to look at babe that helps me think and makes my life easier. almost to the point that I type no more than 3 chars per word and the code completion takes care of the rest. The reason I love VS is it is structured and rarely wonders off the path it was made for. it is evolutionary and totally makes c# the nicest thing to work with. I don’t have the best development machine. it’s still 32 bit so I’m governed with 4 Gigs of memory and even though.. I can easily open up 3 applications. I can debug more than one session at a time while having my back-ends open and the views spread over 3 screens with some memory to boot. On top of it all my Mail is still running in the background and I can have link running and keep my browser on Facebook (very heavy recently). I am the happiest when developing like this. VS 2015 is even better than 2013 which was the shit and the home of several of my applications. I’m not going to say it is without fault. No one is ever totally happy with an IDE and I’m no exception. What I can say is that I might not like everything but I adapt easily and do see what they meant by doing something in some way. MS is good with that. Git Hub works so sweetly and moreover reference loading and using NuGet is like visiting a one stop shop. You don’t have to use external processes ever but if you must well…. it’s a breeze. Just one more thing because I can go on about my favourite IDE for much longer but this group of readers mostly agree with me any way, is that I feel at home when inside the IDE. they are all so similar and although none are the same they are all so familiar that you can just as easily work with VS 2005 as well as VS 2015. the 10 years in the title makes you excited where other lesser ide’s tries something totally new almost every time they change something. when asking people what IDE they prefer they almost always say something stupid like “Eclipse” because it isn’t platform independant. I know some of these people and I can assure you they do only Windows development. They prefer the IDE because of lessor platform constraints but never actually uses that feature, it’s like buying the best 4×4 to drive around in the city (you can stop anywhere you just can’t afford to go there)…. most of the time users develop for cellular phones and tablets on Android and they develop for one platform. they can port to others and that is nice but don’t brag about something you don’t even do.

    Now to get back to my reason why not to come to work anymore. I am doing Android development now. I hate it. I tried the Xamarin route but have to tell you that it is just the syntax that is familiar. the change for me is a lot like going from winforms to MVC. it’s different and the free license that ships with VS 2015 is worthless and actually just puts you on Xamarin’s books. they will contact you within 48 hours after starting your first “small” Android application. Buying Xamarin is not worth while for me since I know and love Java so I’d rather just use one of the many free IDE’s available. So after reading a lot of googled pages I decided to go with Eclipse. Quite a download and setup to get going but anyway… I open Eclipse and let it create the menu system and my first page. It creates some code for me and I’m ready to go. that wasn’t too bad albeit a little slow but hey.. I put some code, just a grid and filled it with some data. I had to revisit the old hello grid with data routine to get back into the java thing but damn it is slow. I open the task manager to see my app grew into this monumental 700megs. a bit big and consequently one google search further opened up a different story. asking what would you use showed Eclipse winning by a land slide. asking why wouldn’t I use Eclipse more than negated the win by a landslide 🙂 … I’m confused. A long story short I tried it and it failed. I’m using Android Studio now and it is just a little better. I can’t use the emulator because a two page application and the emulator adds up to 600 megs of memory and the debugging is to say the least weird and unpredictable. the refactoring that so many rant and rave over is well slower than typing the code yourself and that just tells me all the people that like it only just started. I don’t need code generators. I type 70 words a minute and I never touch a mouse. so refactoring shouldn’t be a deal breaker. VS actually does very nice code generation. adding the get;set; with alt r,e is so nice and I do still encapsulate a lot of my code and the newer VS versions do nice get;set; from code ideas. It all works so well and it is sleek. newer versions are quicker and more feature filled than older ones so it is truly evolutionary with a specific group of people listening to the users and implementing what they want based on numbers for requests. they don’t add everything everyone asks for.

    Irony is a bitch. the people who dis MS for being proprietary (not really true for a while now) and say stuff like the IDE is too full of features that aren’t needed help make a thing that it’s own threads don’t know what they are busy with at any given point. there are stuff that hangs when you press a button while some process are running in stead of disabling the button until it is ready to be used. stuff like that never happens in MS because of standards and quality. (when you pay for stuff it’s just better). I work for a salary and have 3 VS packages that I bought myself. people don’t want to pay for anything nowadays but complain a lot. I tell you now these people don’t work for a Windows partner that gives you the best IDE’s money can buy. they probably use or tried the express (upgraded to free community version with more free features) version.

    To Clothar I would like to say: “Go search, is eclipse dead?” and then visit “” and then after reading it just don’t come back with your then definitely angered demeanour. Eclipse is no Netbeans and Netbeans is no Visual studio 6……

    Just one more thing. there are many people out there that are asking if it is possible to extend visual studio to allow Java programming. a lot of people!………

  12. Lot of MS VS fanboys around.
    Wonder if some of them got paid for writing nice things about VS?

    To make it clear: VS is bulky conglomerat of crap driven by Product Managers rather than developers.

    Just try to edit code in debug mode for example.

  13. I don´t know any skilled programmer who favours coding with VS over Eclipse.

    Intellisence under VS …is far away from being ‘intelligent’.
    Inline documentation of classes & methods? A joke.
    Finding implementations of interface methods….good luck!
    Implementation details….not open source – not possible.
    Automatic markup of implemented interface methods? Nope.
    Shortcuts… maybe usefull for people with with 4 hands.
    Hotswapping of code while in debug mode…not possible.
    Instead: Press ‘pause’ – change code – press continue….well.

  14. “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.”

    Dare I ask you how big was the project you tried Eclipse on?

  15. voncris

    It’s ludicrous how extreme people can be when attacking their beliefs… About half of the comments I see here are fundamentally biased: VS is crap and Eclipse is brilliant or the opposite. Why not agree that both are very good (compared to a lot of other tools that exist out there) but each is better suited to certain tasks and to certain personal preferences?

    In reality, it’s hard for a professional programmer/software engineer to avoid having worked with both IDEs during the years. In my case, I have used VS for more than fifteen years and Eclipse for about four. I was generally happy with both, and of course I had certain unpleasant moments with both. For Windows development I’d choose VS without a second thought, while for Linux Eclipse is just as good a choice and for Android you have to widen your horizons.

    My two cents…