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.
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.
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.
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.
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 :)
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.
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
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.
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.
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)
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?
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
> 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.
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.
>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.
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.
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 :)
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.
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 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.
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...
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.
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.
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.
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.
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.
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.
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.
> 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.
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.
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 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.
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.
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.
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.
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.
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.
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.
148 comments
[ 3.1 ms ] story [ 240 ms ] threadLike COBOL, I believe Java will continue to be the bread and butter of application programmers long after crossing popularity curves with a dead slug.
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.
And of course, you're not really targetting the JVM when you're programming Android, but Dalvik or whatever runtime powers Android these days.
Which IDE will be the next big thing?
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.
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.
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.
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)
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".
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.
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.
Too many knobs. All IDEs are customizable to some degree, but they try and maintain a general sense of coherence. Eclipse, not so much.
Certainly Eclipse has left them plenty of room to swoop in, perhaps as the alternative to IntelliJ.
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?
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.
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.
A classic example of Conway’s Law in action
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.
From the article :
> Eclipse 3.x was a fast, native looking IDE
What?? :)
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.
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.
The price is probably the lowest cost of a closed source solution.
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.
ad rem - I could never make myself using Eclipse - it always felt like getting in the way instead of helping.
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.
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.
I remember this word from the movie submarine.
https://www.imdb.com/title/tt1440292/
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.
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?
Java Hotspot has always been a huge productivity booster.
I think they've retrofitted Mono to run in interpreter mode or something in order to get around those restrictions
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 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.
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 :)
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.
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.
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.
I mean, it's not even difficult to find, File>Export and File>Import.
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.
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.
Neither do I. I don't find any harder than Visual Studio.
http://langserver.org/
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.
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 had to change to PHP Storm, which is, IMHO, the best PHP IDE so far, and worth the price.
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.
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.
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.
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?
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...
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.
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.
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.
That being said, programming in Eclipse reminds me of simpler times where I would program just for fun.
That is not how I recall it.
Switched to jetbrains IDEs now though ha
I'm also not happy with embedded vendors constantly pushing Eclipse based IDE's.