The Fall of Eclipse (2016) | Hacker News Reader

The Fall of Eclipse (2016)

movingfulcrum.com

135 pointsjavinpaul148 comments

I actually question whether the real story is the fall of Eclipse or the rise of Intellij.

My impression (as someone who used both) is that Intellij IDEA was significantly better than Eclipse (to the extent that I went out of my way to be the sole developer who used it on a team of Eclipse users) but that it was not widely used. Then they decided to release the community edition which enabled people to try it without making a financial commitment. (The "free trials" they had before weren't achieving this -- people knew that any time spent climbing the learning curve would be wasted if they didn't shell out money.) Once people had a chance to see it, they chose Intellij in large numbers because it was a superior product.

For ME, the lesson to take away here is not that Eclipse should have had a more polished project and a more organized organization, but that Intellij was enormously successful because they released an open-source version of their product, and to wonder whether a similar opportunity applies to my own products.

I think it was both: the community edition was certainly a big win and Eclipse got worse. I distinctly remember Eclipse getting horrible before considering other options and finding out about IntelliJ CE.

Did it get horrible, or was it always horrible and the sharp edges finally knawed on you until you looked eleswhere?

I know when I first picked up Eclipse I was blown away by the power(coding in mostly Kate at the time...), some level of rose tinted goggles as first introduction to a proper IDE.

In my experience, Eclipse used to be good and it suddenly became horrible, and it was pretty clear when this happened: around the "Juno" major redesign (which, like I mentioned elsewhere, was both a huge redesign and lacked any kind of serious testing because of budget problems).

It wasn't a gradual, this-is-slightly-becoming-worse affair. It was abrupt. Eclipse really did jump the shark, and you could see the shark flying in mid-air :)

For a wider and orthogonal perspective: https://news.ycombinator.com/item?id=16941133

That is certainly accurate in my case: I was aware of Intellij's reputation of superiority, but used Eclipse until the free version came out, and then never looked back.

Why couldn't a collective fork the old version, similar to MariaDB's reaction to Oracle's lawyer romps.

They certainly could! That's a basic part of the deal when you offer something as open source.

I wouldn't choose to aid such a project, UNLESS I felt that JetBrains (the company that produces IntelliJ) was being harmful to the community of users.

A perfect example would be OpenOffice. While it was well-run under Sun I thought most effort should go to a single project not to works. Once it turned evil (Oracle) I thought all support should go to LibreOffice.

The rise in usage of the intellij platform also came massively when they decided to make official plug in for some languages, which worked in the ide, but also a "standalone" ide specifically for it.

I know phpstorm saw a gigantic rise in usage, and webstorm too. Right now they're doing it again with their Go ide (which again is intellij with an official go plug in), and their biggest competition is visual studio code, at least from my pov.

I still remember when Eclipse jumped the shark. It was always a complex and somewhat bloated IDE, but once you learned how to use it, it was fast and had plenty of useful features, refactoring was a breeze, etc.

Then they did that major UI redesign TFA mentions. I remember thinking "I can't believe nobody cares that this is slow, nothing works and the UI is unusable. It used to work!". Then I read the Eclipse forums and found out that there was a major UI redesign with no automated testing and very little manual testing, and the reason was "unfortunately there's no budget for testing". This was the word of the actual official devs, by the way. They decided to do a massive rewrite without testing. It boggles the mind. I guess the lesson here is "don't redesign something if you can't test it works", which really shouldn't be a surprise to any software developer.

Then the other nail in the coffin was when refactoring in Scala was so broken as to be unusable -- yes, I'm talking about Scala IDE, the "official" Eclipse-based IDE for Scala. Refactoring methods was sometimes so broken it actually inserted gibberish; I don't mean it got confused, I mean it actually inserted unparseable code, random parens and extraneous symbols. It was embarrassing. I think it got better later, but by that time I was already using IntelliJ CE.

Everyone blames the Eclipse foundation, but really they set the bar high. The only IDE to rise above it has been Intellij imo.

They missed the boat on JS. That was a big issue for me as a full stack dev. When it became clear they were going to drag their feet forever on updates to JSDT and not support the plethora of languages that suddenly seemed to come from nowhere, I had to bite the bullet and go to Intellij.

Eclipse is like a nice house in a neighborhood that needs some serious renovations. Intellij is move in ready with gleaming countertops, fresh floors, new appliances etc. Can you tell I'm house hunting?

Netbeans was also a lot better than Eclipse IMO (though worse than IntelliJ). For Java and friends, anyway; I’ve never really used any of them but IntelliJ for non-JVM stuff.

Maybe I'm really misremembering or didn't pay attention to this UI redesign. I was a somewhat regular eclipse user 10+ years ago, wrote a plugin as part of my thesis (in late 2009) and used newer versions in the last 5-6 years, it never felt really different?

On the other hand I've never been a big fan either. Developing plugins wasn't fun - getting various plugins to work together wasn't fun either. It was an OK IDE for Java and some other languages...

To me Eclipse used to be the gold standard for Java (it wouldn't even have occurred to me to use it for other languages, which usually had their own IDEs anyway. This was before Scala).

I didn't remember the exact version that jumped the shark, but TFA mentions Eclipse 4, so I googled and it must have been Juno (about 2012, then). It truly was night and day: the previous version of Eclipse was fast and responsive, and everything more or less worked, and then we got Juno which was completely unresponsive, took ages to do anything, it randomly froze or slowed down, and all sorts of widgets constantly failed to render or displayed error messages. Simply killing Eclipse because marketplace or some index update took too long became the norm. I remember thinking "but this is a SOLVED problem! All of this used to work! How can this be happening?", then reading the forums and finding out about the complete UI redesign and that they didn't have the budget to test it thoroughly. I'm not talking as a plugin writer but as an end user. It truly was a horror story.

The Scala IDE thing is more understandable because it was something new and Scala is a complex language. Still, it was embarrassing that this was the official IDE and it was so bad. IntelliJ was initially also very bad at Scala -- I remember it constantly gave compilation errors for perfectly good code -- but then it got improved to the point of usability, while Scala IDE remained slow and unusable. At that point I switched.

I ran away from Eclipse after two events.

A version they released where SubEclipse's installer was broken on a fresh install. The work around was install the previous version, install SubEclipse, then upgrade.

And then the next release after, CDT Plugin wasn't compatible with the new version.

The first case it was obvious no one tested installing SubEclipse on a fresh install. The second drove home that any language other than Java was going to be a bastard step child as far as the dev's were concerned.

> The first case it was obvious no one tested installing SubEclipse on a fresh install.

That sort of thing is embarrassing. You just know some junior dev thought "well, it worked on my computer!". I don't mind when an experimental new feature doesn't work, or when some obscure corner case is broken; shit happens. But when the main, "happy" path for a major plugin doesn't work, the project is in serious trouble and you know it's time to consider jumping ship.

I use both. Jetbrains is better, but it costs money. Its worth it to save the time figuring out eclipse. I use eclipse because I'm maintaining some tomcat code, and the code live in an eclipse project world. Eclipse works and once set up it does it job well. The truth is its just too complex. I still can't get it to work with Git. Eclipse is free (since I use it professionally I donated.)

one example in Jetbrains I can rightclick a file or folder in the navigator and search there or inside there. Eclipse(oxygen) there is a search menu with 12 items. Most of those pull up a dialog box with 7 tabs, most of which have some sort of search option which I hope have sane defaults. Sure its more powerful, but its way more than I need 99% of the time.

I do think that the price as a cons being like 15$/month is kind of a negligible cost if you're using it every day for multiple hours.

If you save around 15 minutes per month the cost is already amortized.

It is not just the price - which might be OK for someone who uses it for several hours per day in a paid job but less palatable for those who don't get paid for their work or who only occasionally need it - but the mere fact that you need to get a license to use it instead of just downloading the thing and firing it up. It is one more step to take, one more thing to go wrong, one more dependency over free software. Given the prevalence of licensing conflicts and the stiff penalties demanded by copyright holders over such issues I tend to go out of my way to avoid exposure to such issues and use free software whenever feasible.

JetBrains is great. I happily paid for that over Eclipse.

I agree that the search in folder is lacking, having to select the folder before to use "search in selected ressources" is annoying. Personnaly, I just remove all the menu item other than file search.

Usually, I use the text search, with a file filter for the various sources files of the application: that way I can find the same variable/method/class across the java, jsp and configuration files.

" Its worth it to save the time figuring out eclipse."

We talking about people making 100k+ but are worried about spending a few hundred for a better tool. It just shows that the same amount of money is valued different in a different context. Spending 500 more for a better laptop is being questioned and two days later you got to dinner with some VPs and they blow more than $200 per person for wine and food.

I don't know specifically about InteliJ, but the product price is usually the lowest cost of a closed source solution. I work in a government owned company. We have strict procurement rules that we must obey to buy things. Beyond the procurement bureaucracy, now we have to manage how much licenses we have. The install of a new instance in a user machine must be tracked. A user can't by himself install the software, we must have specialized persons to do it. To setup test and/or disposable environments is a hell. If we reach the maximum of licenses, a high payed employee must spend time searching for who is not using the software to uninstall, and surely the person won't be available.

The price is probably the lowest cost of a closed source solution.

We had a similar experience with a closed source profiler. We paid for it, and the vendor repeatedly sent armies of sales engineers and even a core developer to help us use it.

Because of licensing enforcement mechanisms (we had a site license, FFS), we couldn’t figure out how to push it as part of the product to test or production clusters, so we just use perf, even though it has maybe 1% the functionality, is frequently wrong, and we desperately need the 99% missing functionality.

You definitely have to be careful. Some vendors are awful. Jetbrains is pretty easy though. Pay your subscription and you are ready to go.

JetBrains does a pretty good job making this a bit less painful. They have a license server you install that dishes out floating licenses to IDEs. Floating licenses are released after 2-3 days, so if someone isn't using the product it doesn't consume a license.

It all depends what of developer you are. If you work as a contractor it makes sense, but people working as employees have no incentive to buy more hardware and/or software.

I read this the opposite way: it's worth it (buying intellij) to save (the enormous amount of) time (you would spend) figuring out eclipse.

Not everyone lives in US and earns 100k+… However, even you you get 1/3 of that, if having a better tools speeds you up it's still worth it IMHO (thus I took the plunge and migrated from NetBeans to IntelliJ a couple of years back).

ad rem - I could never make myself using Eclipse - it always felt like getting in the way instead of helping.

Jetbrains costs money, but it's a rounding error for a professional developer. The full Jetbrains toolbox costs less than a dollar a day. My office spends more money on coffee for the breakroom than we do on Jetbrains licensing for our developers.

The problem is not making the payment, is to convince the company that everybody (or even some people) need that license. In some companies this is a lot of trouble.

It's saved me enough time, energy and tears to justify buying my own license ten times over.

My sympathies for anyone in a company so gimped that they don't allow developers to install software on their own development machines without forms signed off by seventeen people, a sacrifice to the IT administrators, and a 21 day waiting period.

The free version of IntelliJ does more or less what many people want.

Still have no idea how to use Eclipse after 10 years. Vim, Emacs, VS Studio, VS Code, a few proprietary ones - very easy to figure out.

Eclipse seems to be a magical combination of hard to use, slow, and hated.

Was there a golden period? Was it great for awhile, and now is past it's prime, like MS Word?

In our use case, which is developping a project using Tomcat, I've found Eclipse to run rather well and not hard to use. So YMMV

I used Eclipse for 5 years starting with 3.0 and hated it from day one. I started programming in Java shortly after it first became available and loved it. Eclipse managed to suck all the fun out of using it.

Really? I cut my OOP teeth in Java and IBM's WebSphere Application Developer tool, which was vanilla Eclipse with a bunch of WebSphere plugins that extended functionality here and there over the open source version. Eclipse always just clicked with me. It was not hard to learn (though to be fair I had company-paid training on J2EE dev using the tool) and I still use it today.

Maybe I am too stuck in the Eclipse mindset. I find the IntelliJ offering to be very hard to use with a proficiency anywhere near what I have with Eclipse.

I don't know if I will ever join the IDEA crowd. NetBeans can go jump off a cliff.

Eclipse is a direct descendant of IBM Visual Age for Java, which branched from VA for Smalltalk.

VA was an excellent tool for Smalltalk insofar as it allowed you to work with a big soup of classes, abstracting away source files to the point of near invisibility.

Fitting Java required a bit of shoehorning, and I must admit VAJava was an acquired taste for me. I had to sink or swim as VAJ was the official tool of my job work environment.

Having grokked VAJ, Eclipse was a godsend for me. It was similar enough that I had little learning curve, coming from VAJ; and it was a complete, professional IDE for $0. At the time Eclipse was gifted to the Java community, the alternatives were either costly or minimalistic and crude.

Eclipse continued to get noticeably better from release 1.0 to the early 3's, and I was honestly excited about each major upgrade. I would say that yes, this was Eclipse's Golden Age.

IIRC, One of the Gang of Four was the project manager of what became Eclipse afterwards. That and the rest of the environment brought a fair share of bad design choices. Have you ever tried cooying an Eclipse workspace in a different directory, you would recognize the pain.

That's Eric Gamma. And I believe he developed the Monaco editor, which is/was the core of Visual Code, and is part of that team now.

hard to use, slow, and hated

A classic example of Conway’s Law in action

ha, you might want to try to use Kotlin then and, if it applies as well, you might like that :D

I think there was a golden period for embedded systems and other non-Java developers that started about 10 years ago but maybe it's over, not sure since I'm not working in that space right now.

A lot of vendors wrote Eclipse plugins instead of doing their own IDE and everybody won. You could integrate auto-complete, compiler errors, source control and debugging all in one IDE with a little hand-tuning. You can get this to work across multiple toolchains, not just gcc. Sure, Eclipse is a hog but it still seemed better than having three ugly and buggier vendor IDEs on your machine.

IIRC, it was the way that Eclipse did/does the "explorer" window. It always had extraneous (meta stuff) in there that always drove me crazy.

I started using eclipse... already 15 years ago ? I never liked it, but at those times there weren’t much alternative beside vim dreamweaver... as ColdFusion :) moved to Java it looked promising but the horrible UI, the random errors, and its slowness were so frustrating.

From the article :

> Eclipse 3.x was a fast, native looking IDE

What?? :)

I'm really grateful to the Eclipse Foundation because they changed my life giving a scholarship to a little kid in Europe that pretty much never had left his home and flying me to San Jose. Changed my life.

But they truly killed Eclipse. Eclipse probably never had to go beyond being what it was at the beginning, a wonderful IDE.

I started using IntelliJ in 2008 (so it was at version 8 I guess) and I liked it so much more back then. So many awesome features presented in ways that make sense.

With Eclipse, I was stuck by the following weird design decision: All your personal preferences such as keybindings were not saved globally but as part of your current project. What were they thinking? Who would want different keybindings for different projects, think of the muscle memory! Maybe there is a use case for having some specific keybinding for a particular project, so they could have made a way to override your global settings in such case... but not make the very first thing you do, customize it to your liking, a very weird thing different from how every other program works.

Eclipse Keybindings are stored per workspace. A workspace can be used to develop multiple projects.

You're right, I remember it now. I used the wrong terminology in that case. Honestly, the end result is the same. I'm sure there were reasons to use multiple workspaces for different pieces of code and the same user of the same program would still want it to look and feel the same rather than getting thrown the defaults back in your face when starting a new workspace...

You can easily import your preferences into your new workspace.

I mean, it's not even difficult to find, File>Export and File>Import.

But why are they separated by workspaces in the first place?

I use different workspaces for different projects because of differences between code formatting. One project uses 3 spaces and the other uses four spaces. One has curly braces on the same line and the other on their own line.

You can also easily check it into subversion as part of your repo, which probably many people painfully remember.

But that's exactly the problem! The minute you want to change a key binding or a hotkey, you have a re-export that change to all your workspaces.

Honestly it reminds me of GIMP taking years to finally implement an MDI interface. If only eclipse let me keep the same bindings, UI, etc across different workspaces I probably wouldn't have switched.

I personally like eclipse more than Intellij IDEA. I tried using IDEA for a month and even after getting used to the shortcuts I found eclipse more productive and hence faster. I did not benchmark for my usecase. The most frustrating part of Intellij was a 2 second pause whenever I tried to run unit tests even though I turned auto-compile on. Eclipse feels way more responsive to me for refactoring and running tests.

EDIT: Although I would like to add that I liked Intellij VIM integration more. I have been using Vrapper for Eclipse and it is decent but not many people are contributing to the project for a while which raises doubts on it's sustainability: http://vrapper.sourceforge.net/home/

"That era is now over."

Not sure that is true (pedantically), as my son is building Minecraft modules in CodaKid, and they have him using Eclipse, I'm sure b/c it's free: https://codakid.com/. (They have great classes, FWIW/IMO, not affiliated.)

I also don't get all of the "Eclipse is super-hard to use" comments in the thread.

Look, I love LPS and think that now that we have the luxury of local cross-process wire calls and being fast enough to provide butter-smooth IDE features, that is definitely the way forward as a cleaner, less-coupled architecture.

But whenever I pop open Eclipse, it's still faster, runs tests faster, debugs faster (for Java code), than VSCode does (for TS/JS code). Perhaps its Stockholm syndrome, but as a user I really don't think it's that bad.

Where I believe it is bad, and the OP alluded to this, is on the internals/plugin side of things; it sounds like life as an Eclipse plugin developer really, really sucks (see ScalaIDE/etc. pain), and given that the pre-LPS architecture of every IDE was "in-process plugins", that, IMO, is what really "killed Eclipse"/it's momentum.

Especially with open source, where people have to enjoy what their doing to contribute, and AFAIU I don't think I've heard of anyone every enjoying Eclipse plugin development.

But, anyway, LPS to rescue: democratized IDE development, all from within the safety blanket of your preferred language.

> I also don't get all of the "Eclipse is super-hard to use" comments in the thread.

Neither do I. I don't find any harder than Visual Studio.

LPS?

Sure, sorry, Language Server Protocol:

http://langserver.org/

So I'll throw in my two cents. I really liked Eclipse when writing Java programs for fun, and by myself. When Eclipse started to turn bad for me was using it in an environment wth a) other users and b) a build system outside of eclipse. Trying to use it with, say, Maven ended up with this strange combination of things that never quite worked right.

Either you would let Eclipse's black box maven plugin do the work (which half the time didn't seem to build for whatever reason) or run maven manually, which would build great, but then you'd always have to remember to refresh your Eclipse workspace in order to get the application to be picked up by your Tomcat config, etc. It was just cumbersome.

I find those who think it's harder have never used it or bother learning it. I find complexity to Intellij a similar level.

> I find complexity to Intellij a similar level.

Yeah. I recently had to use IntelliJ after a long period of using Eclipse. IntelliJ does some things better and some things worse, but IMHO, its strengths weren't compelling to override its weaknesses.

> I find those who think [Eclipse is] harder have never used it or bother learning it.

I find that very easy to believe. Some developers just don't seem to want to learn their tools, some want to be elitist about their tools, and the intersection between those sets is embarrassingly large.

I'm okay with Eclipse. Here's why. As a consultant working at clients typically there's enough lockdown where I end up having to use Eclipse. Because of that I haven't had much opportunity to actually use Netbeans or IntelliJ at a client. So like someone mentioned below I just sucked it up and dealt with it.

It's not perfect and I definitely get some cryptic errors but I'm actually pretty happy with it now. You should definitely add some plugins to make life easier. I like the TypeScript plugin by Palantir, SonarLint for Eclipse, DevStyle by Genuitec, and the Gradle Buildship plugin. eGit seems particularly buggy but I like it. If anybody has any alternatives I'd love to hear about it.

Have you ever heard of Stockholm Syndrome?

Back then, Eclipse was this big, bloated and slow IDE. IntelliJ was slim, fast and much more intuitive and powerful in terms of refactoring, etc. Today, IntelliJ is big, bloated and turning slow.

Which IDE will be the next big thing?

It's true often enough to beg a question. I wonder if trying to maintain divergent builds of an IDE (core + plugin/bloat) would actually make sense?

And then let the market give the company feedback on which it prefers.

My gut says architecture decisions to enable bloat would still affect the core release, but maybe not? The central issue seems to be disconnect with what the market wants.

Intellij has all or many of it's features as plugins, I think Eclipse had a similar architecture, the reason I switched to Intellij was the extra features and the good support for other languages

It dependa on which language you'd want to use. Qt Creator does its job well for C++ although it does have a few kinks to iron out.

There are multiple ways to vastly increase Intellij performance. They also have 'Auto-share Settings' feature so you can keep a whole team in-sync with them through a repo.

tweaks like:

- they added their own custom property that speaks for itself: 'editor.zero.latency.typing=true'

- it runs on a JVM, so update the JVM settings. (Like most apps, they ship with defaults that assume you're running your IDE on something with the memory of today's phone)

- disable all unused plugins

This comment might seem like evangelizing but I find Intellij to be what an IDE should be in many ways. It would be nice if there was a feature to use more performant settings. But that's likely a rabbit-hole to auto-determine for all variety of customer env. Maybe something to make people aware of their options at least would be a middle-ground.

Isn't zero latency typing enabled by default now? I can't find the documentation now, but I clearly remember reading that.

People, Intellij's performance is fine, just like Eclipses was.

Stop buying cheap old macs or switch to PCs. Tired of the same crap arguments. If your company doesn't want to spring for 3k laptops, get a 1k win laptop with the same specs.

You can't fix code bloat with a faster computer. At least not for long.

I don't really find this convincing. It seems like the data comes from a survey conducted by ZeroTurnaround which isn't really scientific evidence. I have a feeling that there is still going to be a significant market for a full featured, free Java IDE for a long time to come, though that's also an unscientific opinion :)

I remember back in the late 90s I had bought some Borland JBuilder IDE (shrinkwrap, at software store of course), so when Eclipse came around it was awesome.

And don't forget how ugly those Swing-based IDEs were because of the ugly, non-cleartype fonts in IDEs like Intellij. Eclipse used SWT which used native widgets if possible.

Eclipse had a plugin for just about everything, but the plugin-hell got to the point that I ended up having many installations of eclipse because the plugins for various languages, frameworks wouldn't play nicely with each other.

But one thing that always drove me crazy about Eclipse that never got fixed was the intellisense/code completion. They could never get it work without pushing some key combination instead of being able to autocomplete on the fly like Intellij, Visual Studio. So you either had to wait to get to the dot to some code completion or manually press ctrl-space which drove me crazy. I read that there was some strange architectural issues deep in the bowels of Eclipse that prevented anybody from fixing that, but who knows.

By the time Eclipse 4 came around I didn't really have a need for it anymore, but remember that they were pushing that web-based IDE and didn't think that spending limited resources for that was a very good idea.

But I'm happy that Eclipse was out there and thanks to all the devs that made it happen.

On a side note, is Netbeans much of a thing anymore? I'm guessing after the Oracle takeover, it fell to the wayside, but it was probably on the downslope even before then. That was a snappy little IDE though.

Netbeans was better/easier to use than Eclipse for a long time in my opinion (100% accept that isn't worth a whole lot). I vaguely remember that in about 2010/2011 trying to use the maven and git plugins for eclipse together and hitting a lot of errors. Netbeans wasn't perfect but it worked AND used the system installations of git/mvn. Also, Ive never understood why Eclipse insists (at least last time I used it) on importing files/directories into some sort of workspace decoupling the files you see in the IDE from those on the disk.

Switched to jetbrains IDEs now though ha

I studied Java then taught it for a couple of years about 2001/2. I even got the Sun Java Certification. As luck would have it, I never programmed professionally as Java developer. Last year I decided to contribute some patches to a Business Intelligence (BI) tool written in Java. I could only afford a few hours a week. I tried Eclipse, didn't get anything done for a month. Switch to Netbeans, and was able to contribute my first patch within a few hours. Most things just worked, I didn't have a good handle on the intricacies of Netbeans but I was productive. I know Oracle is "evil" but that didn't stop us using Java. Not sure why Netbeans usage is higher. It really is a good IDE.

Eclipse has for years felt like someone generalized both IBM and Java's beliefs and built an IDE.

That's good for some types of coding, but bad for others.

... then the nail in the coffin was going down the rabbit hole with plugins. The bazaar model only works if you have enough shopkeeps. (No offense intended to the gracious maintainers of Eclipse packages, but many could do with a LOT more people helping)

Actually Eclipse was a product that IBM designed in the 90' : VisualAge (I used it at that time, it was really slow on an average computer).

In the 2000 IBM renamed it "WAS" and it was its main studio for J2EE (Websphere) developpers. Some people really liked it.

Then IBM opensourced it as "Eclipse". This name was perhaps a pun on "Sun".

I think most people are aware where it came from. ;)

Been a Java developer since 1999 and have used everything, MS Visual J++, JBuilder, NetBeans, Eclipse, IntelliJ. Sadly I just got the "joke" :( Never put two and two together, I just thought it was a cool name...

What happened to JBuilder? I had used for a while earlier. Seemed good then. (ex-Borland fan here.) Did it get messed up in the general mess up that Borland (aka a few other corp names over the years) did to their once-good products, or was it some other reason?

>Then IBM opensourced it as "Eclipse". This name was perhaps a pun on "Sun".

Yes, I had read that rumour too - that it implied the Eclipse of the Sun ...

Of course the Eclipse logo (last I checked) also implied that.

Meh. I still find Eclipse to be far superior to Intellij. I gave Intellij a try last year and just didn't find anything appealing about it.

OTOH, Eclipse, while different releases have been better or worse than others, and despite a rough period starting with the whole "Eclipse 4" thing, the Oxygen version has been very nice. I started with a RC of Oxygen and it's worked so well I never even bothered upgrading to the actual release version.

The only thing that really annoys me about Eclipse is that they killed off the TPTP sub-project, and I really liked their profiler back in the day.

I stopped using eclipse because scrolling became super janky on mac after an update. Seven years on, the bug is still open: https://bugs.eclipse.org/bugs/show_bug.cgi?id=366471

Weird it’s oetfectly fine on my MacBook Air

I feel like VS Code is on it's way to becoming the next generation of Eclipse. It's a great platform, but now it's practically just a plugin framework. I'm hoping the maturation of the open source world will have us not repeat the same mistakes.

Classic Eclipse plugins were all either created by big software vendors who wanted to create a good developer experience for their products or eager amateurs who were scratching an itch. VS Code plugins are more like good open source projects that have contributors and reviewers and frequently sponsors. Microsoft is strongly supporting it, but not with a heavy hand even if it cannibalizes some Visual Studio sales.

In my opinion, The problem with Eclipse is not that it turned into a plugin framework, but that it ended up being an IDE framework.

Too many knobs. All IDEs are customizable to some degree, but they try and maintain a general sense of coherence. Eclipse, not so much.

You could be on to something. There are quite a lot of Java sessions scheduled for Microsoft's Build conference this year.

Certainly Eclipse has left them plenty of room to swoop in, perhaps as the alternative to IntelliJ.

I wonder how much of this was due to android no longer shipping it's SDK as an eclipse plugin, but moving to android studio

This. That said, the gripes listed in the article are minor to working with Android Studio and gradle on a medium sized codebase. Yuck

I'm using Intellij now, but used to work with Eclipse. And one thing that I miss is quickly starting tests. In Eclipse it feels like tests start without compilation and I get instant feedback. With IDEA you have to wait a second or two before it starts running the tests. I know it doesn't feel like much, but it's really annoying if you are doing TDD.

I started using IDEA because I wanted dark theme and Eclipse didn't have it. Probably even now you can't get nice looking dark theme in Eclipse, not sure, correct if I'm wrong.

I recently started using VS Code for the same reason - we're doing a lot of Ansible playbooks and Kubernetes manifests and editing yaml with Eclipse's dark theme results in a lot of charcoal text on a dark grey background.

Quite a bit of negativity around Eclipse found here, below are a few of my perspectives.

Eclipse is one of those tools that I've found to give dividends over the years, I mainly used Eclipse CDT for C/C++ development, and then moved on to Scala and the normal Java based Eclipse. There's also DBeaver for Database work.

The learning curve was steep, mainly around setting up projects so the compiles happened outside the IDE. I mainly used Eclipse to discover the code (call hierarchy was a godsend) and for finding definitions, autocomplete etc...

Over time though the investment has paid of, going from Java, to C/C++ to Scala, to DB work (dbeaver) all have Eclipse underneath it and the same principles apply.

A few free plugins like Vrapper that give Vim emulation are also super nice.

A huge plus is that if/whenever I switch jobs, I don't need to harass anyone in the finance department over licenses. This scales up from the scrappiest of startups to the largest of red-tape laden mega-orgs.

Eclipse has fallen out of fashion but I doubt it'll die, its one tool in my toolbox I can always reach for.

Totally disagree. IMHO I’ve tried both IntelliJ and Eclipse and felt IntelliJ to be really complex and non intutive. I can do tasks very quickly in Eclipse using shortcuts I’m familiar with. I also often feel the features of IntelliJ are over exaggerated and almost all the things can be done in Eclipse if you know how to use it. Once, I sat with a dev who was trying to evangelize IntelliJ in our workplace (and influence our manager to purchase licences)and explained alternatives in Eclipse for almost all the ‘awesome’ features he showed in IntelliJ. He simply didn’t know what eclipse could do. For me Eclipse starts really fast, I really like the UI better than IntelliJ. I believe Eclipse provide really awesome features for a free software and on the otherside IntelliJ doesn’t provide enough features for it’s heavy price. It seems many programmers (not all) these days feel fancy about boasting they use a paid IDE to hide their actual incompetence in programming. ( Ps: opinion only from java perspective)

In the embedded world I keep getting run over by vendors peddling Eclipse IDEs that look beautiful and support a nice dark theme that I really miss but not enough to say goodbye to IAR and a fast development environment that avoids most of the java overhead. Can't ever seem to have a powerful enough machine to run Eclipse satisfactorily.

I switched to Eclipse for a year, then switched to codelite which mostly does what I need it to.

I'm also not happy with embedded vendors constantly pushing Eclipse based IDE's.

> One only has to look at the TypeScript support in WebStorm as an example of how bad things can get.

I'm a bit surprised by this statement. I've been using TypeScript in WebStorm/PyCharm for quite a while and have been really happy with it. Are there some big flaws I'm not noticing or specific valuable features that they're not adding? Compared with JS and Python, TypeScript coding feels much nicer (as you'd expect when comparing typed vs untyped languages). Comparing with IntelliJ Java, TypeScript support is maybe slightly less magical in one or two areas but seems pretty much on par. I haven't used VSCode enough to have a great comparison, but my impression is that WebStorm is a little more laggy but is more fully-featured.

Edit: I guess since the article was from a year and a half ago, that line may just be out of date.

If you look from a maturity of the Java ecosystem perspective, then even now there's a point to be made.

Even compared to Java IDEs of a decade and a half ago, the refactoring, and other smart-assist facilities in Typescript editors/IDEs is rather weak.

Of course, Typescript isn't generally, totally statically typed, so that brings a whole set of challenges. And Typescript's type system is very complex these days.

But I agree Webstorm (and really the whole suite of Intellij IDEs) does a great job with Typescript. I think only recently in the past month or so, VS Code has gotten unused imports checking.

> Eclipse 3.x was a fast, native looking IDE

That is not how I recall it.

I used Eclipse and my memories are hours spent to install some plugin (sometimes as necessary as Maven or Subversion support), typing some repository address, etc. Running something with apache tomcat was a quest. Sometimes things broke and you had to clean/redeploy it again and again until it worked. When I installed Idea and everything just worked, it was a truly superior experience. Idea is one of very few software products that I bought and continue to buy. I just really respect Jetbrains developers.

That said, there were few things that I liked in Eclipse. Errors were easier to work with. Also I could run uncompileable Java code and I liked it (Eclipse skipped bad code and throwed exception there).

> In my teenage years, having Eclipse as a completely free top notch IDE was instrumental in me learning to program. It meant a poor student could use the exact same tools as a professional. That era is now over.

That does resonate strongly with me. I learned to program when Eclipse was (surely according to the graph) the most popular java IDE. It was at that point a good IDE for Java as well and I was quite happy with it.

But after having used IntelliJ for three years now, I really would not want to go back to Eclipse. I had to use it some months ago when I was helping a student with a project, and it does look quite bad compared to IntelliJ.

You can use Idea CE, it's even open source. It does not support enterprise stuff like Java EE, but modern Java can live without it, run embedded Jetty, for example.

Recently i changed to Netbeans having been using Eclipse at work for years and was pleasantly surprised. Much faster than eclipse, no constant lags and freezes. At home i use IntelliJ. Never looking back to Eclipse.

I share your experience. Netbeans mostly works out of the box and it seems much easier to configure.

When did Eclipse not suck in comparison to Intellij? I've been using Intellij since 3.x, and every time I looked in on Eclipse, there was simply no comparison. Intellij had a far more cohesive design -- at least for me, it worked the way I expected, whereas with Eclipse, I had to spend time hunting for what I wanted to do. Intellij has always looked better. And it has always (up to the last time I looked at Eclipse -- five years ago?) had a much better understanding of the language, and doing the right thing in context.

41% is hardly "lost", its still a significant market share.

One nice thing about Eclipse is that its free and there a ton of plugins for almost every language out there. I use Pycharm as my primary IDE but I still have Eclipse installed in case I want to do something in Perl or Java. And to be honest there are always a couple of little features here and there that I miss.

I've always felt that if there was an Eclipse 'lite' it would garner lots of attention and be the go-to Java IDE for lots of developers. Eclipse got waaay to big and slow and had several bugs where the solution was always 'restart Eclipse'.

That being said, programming in Eclipse reminds me of simpler times where I would program just for fun.

I find the passion behind IDEs a bit bemusing, I've never really felt the strong benefits of IntelliJ over Eclipse, although using Eclipse for quite a few years means the burden of changing is reasonably high. IntelliJ certainly had very vocal advocates, the Thoughtworkers I worked with pushed it very, very hard.

Eclipse I find to be a mixed beast; if you get it into your 'sweet spot' or ideal configuration, it can be perfect. Mine is Gradle based projects (the integration seems to work fine, or use the CLI), and keeping things simple with POJOs, a bit of Spring Boot etc for more complex things. I've worked with truly horrible projects/configurations e.g. Websphere Application Developer which is/was based on Eclipse but with everything and the kitchen sink bolted on. It was slow, buggy, took 30 minutes between firing the IDE up and being able to work etc. EJB's, DB2 database access etc - just a nightmare.

So to me they're both sort of what you make of them; I find the Eclipse plugins to meet all of my needs well, the times I've tried IntelliJ or paired with someone that uses it, I don't agree with the purported benefits.

I use eclipse because it is better supported by most companies. In my company they already know about eclipse complexity and have tools to help with it. Intellij might be better, but in many places you need to be the local guru, which is fine if you want the extra responsibility.

- intellij: As a developer and linux user I dont see the point of paying for an IDE rather than putting the effort in improving an open source one. Therefore, paying for an IDE/editor is fundamentally wrong for me.

Intellij has always been way better than Eclipse, but for a long time you had to pay a small amount for it. People looking at dollars rather than bottom line foolishly chose Eclipse.

Or people caring about software freedom. To this day you have to agree to a Privacy Policy to be able to use Intellij which is why I personally stick with Eclipse.

No one talks about Netbeans! I used to love Netbeans :(

Being used to Visual Studio, every time I needed to use Eclipse I kept wondering how Java developers could tolerate such an environment. Now I know ofc some of it is due to less familiarity and exposure, but it realy felt like stepping back 15 years in time each time I launched it.

In what way?

I'm not sure in what way your Eclipse experience was so atavistic, but I'd like to point out that at least for several years I was aware of, Eclipse had a significant competitive advantage:

Incremental compilation.

You could make a small change, do a Ctrl-S, and Eclipse would compile the change nearly instantly, where all competing products (that I was aware of, correct me if you know better) needed to fire up a Java compiler and feed it at least all changed source files. For me, this was difference of 2 seconds versus maybe 20-30.

> atavistic

I remember this word from the movie submarine.

https://www.imdb.com/title/tt1440292/

It just means regressing to a prior, more primitive, state

Was that a feature of the IDE or the compiler? Or does the IDE have its own integrated compiler that can't be used standalone?

I believe Eclipse has it's own Java compiler, so it was probably a compiler feature.

> I believe Eclipse has it's own Java compiler, so it was probably a compiler feature.

It does, and it's much better than javac for IDE use cases. That's one of my biggest pain points with IntelliJ. They've tried to implement some kind of incremental compilation on top of javac, but it doesn't work reliably and often forced 5-minute from-scratch recompiles on the last project I worked on.

The Eclipse compiler is natively supported in IDEA: https://www.jetbrains.com/help/idea/java-compiler.html#javac...

Incremental compilation is not tied to the compiler, since it has this ability when coding C/C++ applications too. I always disabled it since does not work properly with multi-project with custom libraries. Main project, it worked just fine.

You sure about that?

Eclipse comes with its own compiler and ONLY requires the JDE to develop Java application, not the JDK.

They also claim that its their compiler that implements the incremental compilation

https://www.eclipse.org/jdt/core/

>JDT Core is the Java infrastructure of the Java IDE. It includes:

>An incremental Java compiler. Implemented as an Eclipse builder, it is based on technology evolved from VisualAge for Java compiler. In particular, it allows to run and debug code which still contains unresolved errors...

>...The JDT Core infrastructure has no built-in JDK version dependencies, it also does not depend on any particular Java UI and can be run headless.

Not only that, but what does it matter if incremental compilation is "not tied to the compiler" if Eclipse was the only software that utilized it at the time?

And not only that, but but being able to debug and change code without restarting the debugger was something I was always envious of coming from the .NET side of things.

Java Hotspot has always been a huge productivity booster.

I think that's supported for 32bit applications in the paid version of Visual Studio. At least it was 10 years ago for C#.

With a whole laundry list of restrictions of what can and cannot be changed while running.

I think they've retrofitted Mono to run in interpreter mode or something in order to get around those restrictions

From purely a standpoint of how smart the IDE is with the language (C# vs Java) then Eclipse and Intellij have always trounced Visual Studio - even with Resharper installed and to this day.

Great write up on Eclipse. I also loved the IDE back in the day. It was the closest thing to Visual Studio that was available for free.

Personally, I've found the opposite. IntellJ is clunky and Eclipse is easy to use. The new version, oxygen, In particular.

For PHPers and lovers of Free Software, Eclipse and PHP Developer Tools (PDT) are very fine tools. Long live Eclipse!

Eclipse PDT (ex)user here. PDT worked like a charm until eclipse Mars. PDT on Neo and Oxygen are pretty bad: PHPCS / PHPMD is a nightmare to configure and xdebug sometimes works, sometimes not.

I had to change to PHP Storm, which is, IMHO, the best PHP IDE so far, and worth the price.

TL;DR: Author doesn't like the new look of Eclipse's rewrite and therefore, without further evidence, claims it's dead. There's really not more than incomplete opinion in this article.

There might be a real discussion here, though. E.g. as far as I know anybody who ever tried IntelliJ loved it so much that he never wanted to switch back to Eclipse. In the circle around me, 100% of people. Other people may see different outcomes. But still both Eclipse and IntelliJ where both kind of considered leaders in the Java IDE market for a long time. So it might be really interesting to discuss the strenghts and weaknesses of both.

Also a good discussion could be had how the path to Eclipse 4 developed and how things might've been done differently. That would require analysing other IDEs like the Microsoft's as well.

So, you know. Quite a wasted opportunity, right here. If someone reads this and felt like upvoting, could you put into a few sentences why?

Article Header needs (2016) next to it.

Updated. Thank you!

that's due to decreasing demand in java.

I’m not sure that decreasing demand in Java is what led to a Jetbrains Java IDE overtaking Eclipse. The total pie may be smaller, which in itself is probably debatable and I’m not going to bother researching, but I believe the takeover has more to do with an active android programming ecosystem than any of the other factors mentioned in the article. It would be interesting to see a breakdown between IntelliJ editions with Android Studio broken into its own product line.

[citation needed]

Do you have any evidence to back that statement up? Java seems to be as popular as ever.

Does it matter if they don't? People are entitled to opinions which may seem absurd. https://github.com/prettydiff/wisdom/blob/master/Avoiding_Tr...

While it may be hard to show that Java's demand has decreased - and overall it may well not have since many companies which were using Java will continue to do so just by inertia - but for the latest generation of programmers, specially ones focused on ML / Data Science, Java feels like ancient history

Yep. As a professional developer, I'm way over being excited and enthusiastic about Java; on some days, and having sampled more modern languages, I downright hate it. My guess is that the grandparent poster is mistaking this disillusionment for a decrease in demand.

Like COBOL, I believe Java will continue to be the bread and butter of application programmers long after crossing popularity curves with a dead slug.

What's a good replacement for Java that has static typing and tool support? Is there one yet?

On the JVM, the most solid contender is Scala. It's "better" than Java in a number of ways. Personally, I'm a bit turned off by the very intrusive role of the type system. You may find a bit less tool support than for Java (no surprise) and some of the clever functional-style code you write may run slower than less elegant corresponding Java code. Still, there are a lot of adapters, some big names, and they get stuff done. Scala being "harder" also allegedly attracts smarter developers.

Another statically typed language, non-JVM, with decent momentum is Go. It's like C with a slew of sorely needed improvements. Very straightforward and there's often a single, obvious way to get something done. As a result I find I'm very productive in it. Performance is topnotch too. Tooling is quite good. I'm not sure it replaces Java as an "Enterprise" language for large-team projects though.

Kotlin is another "better Java" language on the JVM. Pleasant enough to work with, but not as large an adopting community. Tooling is good if you like IntelliJ.

C# is Microsoft's challenge to Java. Has borrowed some good ideas from Java and extended them, interfaces well with Windows (obviously). Tooling is good if you like Visual everything and Microsoft.

Now may be a good time to switch to a language that more fully embraces functional programming. F# and OCaml are possibilities, Erlang has a great rep for stability, and Haskell is said to be very powerful but with a daunting learning curve.

I'm experimenting with all of these and have the damndest time making up my mind. There's kind of an embarrassment of choice.

A large number of Android developers would disagree with that statement.

I'm guessing the vast majority of Android development is still using Java as its language, but I would assume with Kotlin being an official language for Android, that will be changing in the next few years.

And of course, you're not really targetting the JVM when you're programming Android, but Dalvik or whatever runtime powers Android these days.

Reply on news.ycombinator.com