
Is Eclipse JDT dying? - pdeva1
http://blog.dripstat.com/is-eclipe-jdt-dying/
======
mmilinkov
"A lie can travel halfway around the world before the truth can get its boots
on"

JDT is _not_ dying.

I am the Executive Director of the Eclipse Foundation, and I am here to tell
you that the commit numbers quoted in the blog post are completely bogus.

The stats shown on the Eclipse project pages only show the activity in the
master branch. At the moment, the vast majority of the JDT activity is
happening in a separate Java 9 branch. If you actually look at the git
repositories directly (see link below for one repo), you can find a couple
hundred commits in September, not zero.

The other thing going on is that the team has been in rampdown mode for the
Mars.1 release shipping in the first week of October. A code freeze leading to
a release is standard operating procedure for the Eclipse project.

In summary, this article is based on incorrect and incomplete numbers, and is
entirely misleading.

[http://git.eclipse.org/c/jdt/eclipse.jdt.core.git/stats/?per...](http://git.eclipse.org/c/jdt/eclipse.jdt.core.git/stats/?period=m&ofs=10)

~~~
zoyo
Hey, just wanted to say Thank you! Keep up the great work. I've been using
Eclipse for about 8 years.

My only major gripe: Why aren't the Eclipse binaries signed with GPG keys? The
binaries are served off mirrors. We just saw XCodeGhost happen. This really
needs to be fixed.

Minor gripes: ARM builds would be nice. Hi DPI would be nice.

~~~
mmilinkov
Zoyo, Thanks for the kind words.

Regarding the GPG signing, currently we sign every executable and jar inside
the zip file, and rely on SHA checksums to allow users to verify the content.
If you think that's insufficient, could I ask that you open a bug explaining
your reasoning?

There are ARM builds available at fedora.org. But I agree that getting those
available somewhere on eclipse.org would be sweet.

I _think_ high DPI is on the list of things to do. Contributions are always
gratefully accepted :)

Thanks for using Eclipse!

------
lchengify
I have a love / hate relationship with Eclipse. On one hand it's everything
I've always wanted development to be: Technically correct, free, pluggable and
open source. On the other hand I've upgraded my computer 8 times in the past
10 years and Eclipse is constant in its ability to always be way to slow to do
anything.

I now use JetBrains IDE's and VIM and it's a totally different world. It's
nice to not have to think about what random Eclipse plugin is colliding with
what other random minor version update that is stopping me from using the
debugger correctly.

Sometimes if a task is complex, annoying and specific enough, it's better to
just pay a company to produce a maintained tool rather than relying on the
open source community to just "solve it for you".

A good analogy might be Gimp vs Photoshop. Gimp is great for learning and gets
you there, but if your job depends on it, it starts making economic sense to
pay someone for something better.

I started using Eclipse back at School and it was great at getting me into
programming. It will always have a place in my heart ... just not on my hard
drive :/

~~~
hugi
I have the exact opposite experience. I've attempted to switch to IntelliJ on
multiple occasions in the past couple of years but I've never gotten it to
feel as fast and flexible as Eclipse. Is it possible you're comparing to old
versions; Eclipse used to be really slow 4-5 years ago, but the current
versions running on an SSD are _blazing_ fast.

If there's one thing I hate about Eclipse, it's that it's kind of ugly :).

~~~
tokenizerrr
Whenever I try to switch IntelliJ I hit a few roadblocks that force me to turn
back to eclipse, sadly.

* No true multiproject/workspace support (with maven integration)

* Slower compile times than in Eclipse, somehow

* Have to hit an extra shortcut after editing a file for a hot reload to happen while debugging

Am I just crazy, or are these really areas that IntelliJ is weaker in than
Eclipse?

~~~
brianpgordon
What do you mean by "true multiproject/workspace support?" You can add other
maven projects as modules into your IntelliJ project using the "Add Maven
Projects" icon in the Maven Projects tool window. And you can also open
multiple IntelliJ projects at once in different windows.

~~~
tokenizerrr
I want to be able to have 10-20 projects open and be able to view their
sources without switching between windows. The project files should also not
depend on each other, but if one of its maven dependency is another opened
project it should use that during maven dependency resolution.

~~~
daddykotex
You can do this just fine with IntelliJ! IMHO, IntelliJ support for multi-
project with maven is better. There are no duplicate resource or type when
looking for something. There is a correct hierarchy view in the sidebar.

~~~
tokenizerrr
Could you explain how? Whenever I open another project it seems to become it'd
own window. I must be missing something.

~~~
brianpgordon
Like I said, open the Maven Projects tool window and click the green plus icon
("Add Maven Projects").

~~~
tokenizerrr
I think I got it to work, somewhat. It seems I need some kind of "master"
project to add all of the other projects to, which seems kind of clumsy. I
suppose it works, though.

------
RyanZAG
Kind of surprised by the comments here regarding speed. Have none of you used
Eclipse recently on an SSD? I use Jetbrain's stuff a lot of the time, but the
biggest problem Jetbrain's stuff has is how terribly slow it is compared to
Eclipse.

Are these comments just relics of experience from years ago, or is there some
secret I'm using in having Eclipse be around 2x the speed of Jetbrains? Just
tried opening an Android Java project in both Eclipse and Android Studio and
the Eclipse is finished loading before Android Studio is even 20%

Other than that, Eclipse is free software which is important in the same way
Linux is important to cultivate even though we have Windows.

~~~
lchengify
So it's never been the SSDs for me, it's always been paging / memory
consumption. When I run Eclipse / JetBrains I set the XmX flags super high on
the JVM to compensate, but it still always felt slower.

Basically I've found that a lot of Eclipse plugins and core pieces associated
with the debugger allocate _a lot_ of heap space that never goes away.

However I haven't used Eclipse in about 3 years (or on Java 8), or for
Android, so if there's something new I'm missing, your point might be valid.

------
alanfranzoni
Imho Eclipse has never been a good ide. Its confusing user experience never
appealed me. But then, it was free and had certain features and was quite
extensible.

Then Netbeans began improving quickly, IDEA had a free edition and Jetbrains
released many good IDEs for other languages as well.

Game over.

~~~
tootie
Eclipse set the bar in terms of having an utterly vast list of features and
wild west bazaar of plugins. It was like market research for the more
sophisticated vendors. IntelliJ has the 30% of features users actually wanted
with a much tighter implementation.

~~~
mamon
My impression is quite different: IntelliJ has comparable set of features, but
the difference is that in IntelliJ those features actually work without
annoying user. this started with a simple but brilliant idea JetBrains
developers had: "disk space is dirt cheap, let's use 1-2 GB of it to store
index, so that autocompletion could work lightining fast". Also, because it
was initially developed by single company and single team of developers IDEA
code (both core and plugins) is much more consistent in terms of quality than
Eclipse's counterparts.

~~~
alanfranzoni
I agree completely. While Eclipse had a lot of plugins, it was often difficult
to make them work together; so I was stuck with multiple Eclipse or eclipse
customizations with a different set of plugins for each one.

IDEA has probably less features, and third party plugins don't necessarily
work well together; but you can see the idea of the "ide as a whole" behind
Jetbrains products.

------
ruk_booze
The log begs to differ

[http://git.eclipse.org/c/jdt/eclipse.jdt.core.git/log/](http://git.eclipse.org/c/jdt/eclipse.jdt.core.git/log/)

~~~
alanfranzoni
Yes... it seems very different than the activity shown on the project page...
108 commits in the latest four months is not that bad. Why such difference in
data?

~~~
mmilinkov
Please see above. It's because the JDT project page doesn't roll up the stats
from its sub-projects, where all the real work happens. We're looking into
fixing that.

------
guelo
I'm always so confused by comment threads like this page. I used Eclipse daily
for 6 years then was forced to switch and now I've been using IntelliJ daily
for the past 2 years. So I think I'm qualified to make a fair comparison and I
still vastly prefer Eclipse. But then I look at comment threads like this page
and it's all about how superior IntelliJ is. It always leaves me confused,
like I'm missing something about IntelliJ but I don't know what it is.

~~~
paperwork
Same here. I haven't used eclipse in the past two years because I've been
doing non-java work. Before that I used it since the beginning of my career,
around 2000. I don't recall having issues with slowness and plugins randomly
not working. When I first started using it, I remember being a bit confused by
projects vs files. That's when I didn't understand the concept of IDEs (as
opposed to text editors). I feel like I'm living in an alternative universe.

~~~
simoncion
I was using Eclipse for a couple of years for C++ and Java work (some of that
work was building things _on_ Eclipse) about three years back.

Once you increased a few limits like the Java max heap size [0] Eclipse was a
bit slow to start, but -once started- was no slower than any other full-
featured IDE I'd used. CDT was _really_ nice, and the Java tooling worked as
well as I expected it to.

The two _really_ big issues I had were the _really_ terrible dependency
resolver -which not infrequently required you to update packages in _stages_ ,
playing the "Which package(s) is giving the dep resolver grief _now_?" game
for several fives of minutes-, and Eclipse's tendency to cache all _sorts_ of
file state. Once you learned what Eclipse cached, you knew what sorts of
things to _not_ do outside of Eclipse, but until then... oh, the mysterious
errors one was likely to receive! :P

[0] Rant: Why the fuck is this even a tunable? Every other program I use
(including software written with a language that targets a GC'd VM like C# or
Erlang) is completely capable of regulating its own memory usage. Why does
Java need me to _tell_ it how much memory it is allowed to use?

------
bhouston
It seems that only one guy is responsible for most of JDT: Markus Keller:

[https://github.com/eclipse/eclipse.jdt.ui/graphs/contributor...](https://github.com/eclipse/eclipse.jdt.ui/graphs/contributors)
[https://github.com/eclipse/eclipse.jdt/graphs/contributors](https://github.com/eclipse/eclipse.jdt/graphs/contributors)
[https://github.com/eclipse/eclipse.jdt.core/graphs/contribut...](https://github.com/eclipse/eclipse.jdt.core/graphs/contributors)

------
mindcrime
Dying? I doubt it. While it's not the tool of the "cool kids" anymore, it Just
Works, and it has gotten better in some important ways with the last couple of
releases. I have to admit, when they started the whole 4.x thing, I was not a
fan, and I do still think a lot of work went into making Eclipse more "web
based" in a way that didn't actually add much value. And as result, the UI got
buggy and it got slower and less stable. But at least with the Mars release,
Eclipse works amazingly well. The performance is reasonable, most all of the
plugins I want to use installed cleanly and work with no problems, etc.

The only real fly in the ointment to me, is something that isn't any fault of
Eclipse itself. The Groovy/Grails IDE has not(last time I looked anyway)
shipped a Mars compatible version, meaning I'm stuck using an older version of
Eclipse for doing Groovy/Grails work. But that's mostly, as far as I can tell,
a side effect of Pivotal dropping their support for Groovy and Grails.

~~~
justthistime_
> it Just Works

That's what I'm praying for every single day before I start Eclipse. Sadly,
Eclipse keeps inventing new ways in which it breaks.

~~~
mindcrime
Interesting... I've had glitches here and there in the past, but most seemed
to be related to certain combinations of plugins. But the Mars release, even
with the Scala IDE, Counterclockwise and a bunch of other stuff added, really
"Just Works" for me.

------
EdSharkey
Eclipse has always been a needed and valuable IDE for Java development. If I
wanted to spin up a Java app with Maven, I could do okay with Eclipse.
Refactoring tools work fine, debugging is great.

Support for languages OTHER than Java, however, vary wildly in terms of value.

One language support that seems to have crossed over into complete
obsolescence is JavaScript. I hate to break it to you Eclipse Foundation, but
developing JavaScript on a WebIDE is completely out of the question for many
of us, so your fancy Orion system is a non-starter. It's mean of me to say,
but I'm rooting for Orion to fail so you can move those developers back to
enhancing the desktop IDE's JavaScript support.

Eclipse JSDT is my only option, and it seems broken and unmaintained. Around
the 2008 timeframe, I was really impressed with JSDT's ability to build out a
type library as it parsed my prototypes, it really understood the type system
when I added JSDocs. It all works ok for rink-a-dink projects that are
targeting the browser and coexisting with HTML. But, for any modern
development like server-side Node.JS or CommonJS browserify/webpack projects
in the browser, ES6 or anything modern, Eclipse JSDT is really up a creek
without a paddle. I can't use you, and that makes me so sad to say because I
_WAS_ a staunch Eclipse user who turned his nose up at JetBrains!

To make matters worse, Eclipse has gotten slower and buggy since the last
major upgrade (Luna?) and WebStorm is cheap and great and amazing at parsing
JSDoc's to the point it practically turns JavaScript into a statically typed
language, and it groks CommonJS and my node_modules folder (with the help of a
little plugin I downloaded.) I admit I haven't tried running Eclipse in a
year, so perhaps the bugginess has been addressed.

~~~
Flenser
Have you tried nodeclipse¹? I haven't tried it yet but am considering it for
when I next have to do a lot of js work.

[1] [http://www.nodeclipse.org/](http://www.nodeclipse.org/)

~~~
EdSharkey
Yes, it wasn't working for me. Not sure if it was my environment or my lack of
patience.

Given the old system they are trying to extend and enhance, I'm not surprised
it didn't work.

------
barrkel
Post open sourcing, Eclipse development was supported by IBM for strategic
reasons, in opposition to MS. When Oracle bought Sun, the strategic
relationship changed, and IBM saw less reason to invest in Oracle tech.

IMO Eclipse is a product of a particular type of engineering, one that is done
on a 9-5 payroll, and never as a labour of love. I've always found it awkward
to use and surprisingly difficult to configure - even simple things like
syntax highlighting is spread over multiple locations in the byzantine
preferences. The whole perspectives thing, and its obsession with you
selecting a workspace, up front, which is distinct from the project you're
working on - it forces the user to adopt its internal idioms and jargon,
rather than the other way around.

Eclipse killed off JBuilder's original IDE back in the day, undercutting it. I
far preferred JBuilder's UI.

~~~
mmilinkov
I sort of agree that Eclipse started out that way (mostly paid for by IBM),
but I am happy to report that the community has evolved a great deal since
those days. If you take a look at the Platform UI project, for example, you
will see a very diverse project, with a lot of unaffiliated committers.

[https://projects.eclipse.org/projects/eclipse.platform.ui/wh...](https://projects.eclipse.org/projects/eclipse.platform.ui/who)

------
mataug
I started using Eclipse as a netbeans convert, I loved it initially until
ofcourse I started using IDEA from Jetbrains. This has been the case with most
of my friends so I'm not really surprised by the lack of interest in Eclipse.

------
thrownaway2424
DRAM shares plummet.

------
chaostheory
imo Eclipse's main flaw was that plugins just didn't work or stay working. It
seemed to have gotten better in later years but it still wasn't good enough
for work. I'm not sure how not using Swing affected development either since
Swing had some huge improvements in 1.7

Intellij pretty much took over

------
anthonybsd
It's really sad to see this happening. I prefer IntelliJ for most of my
development work, but certain things it's completely unsuitable for. Debugging
multi-threaded code in particular in IntelliJ is a very paintful experience
compared to Eclipse.

------
saidajigumi
Many years ago, Eclipse as a whole had a few promising points:

* Open-source, with an apparently large community

* Extensible within itself via plugins

* Some interesting GUI features:
    
    
      * User- and plugin- definable and customizable 
        "perspectives" that captured specific workflows, e.g.
        debugging, language X editing, schema editing, etc.
    
      * For its time, relative to other IDEs (Visual Studio,
        I'm lookin' at you) a much easier approach to managing
        panes and tabs to the user's liking.
    
      * The fantastic ability to quickly narrow the settings 
        pane navigation via text search. OS X's System 
        Preferences later added a similar feature to find & 
        narrow pref panes based on a keyword search.  I still 
        feel that there's untapped opportunity  for GUIs and 
        traditional editor modes (emacs/vim) to leverage 
        spinoffs from this interaction model.
    

That said, Eclipse never seemed to surmount what I feel were its major
difficulties:

* The Workspace -- IMO the most absolutely toxic abstraction an IDE has ever had. All "projects" must live under a "workspace" which is both an on-disk top-level directory+data that users must cope with above their project(s) and an inescapable in-code monstrosity that plugin writers must also cope with. This was a mimicking of other IDEs that thought it was a good idea to maintain an entire separate organizational data structure for code that created a separate hierarchy that duplicated and obscured the on-disk organization, and a short-sighted hard-coding of a Java-centric mindset where any non-trivial codebase was certainly going to consist of multiple interdependent projects. The Workspace was a core architectural disaster. A symptom: it made Eclipse ridiculously painful to use to, e.g., "just edit a python file". Contrast with TextMate's lightweight approach of "a directory is a project" and fast in-project navigation/fuzzy search tools. No state was required other than what was on disk. TextMate's full power and bundles were available with zero friction for either project-centric for file-centric work.

* Speed -- The more time goes on, the less excusable Eclipse's dog-slow performance is. Early on, it was easy to overlook its slugishness, because reasons. Some recent work has had me suddenly delving back into (two different!) Eclipse projects, and its amazing just how the poor the UI responsiveness compares to other modern environments, even on screamingly fast hardware.

* Extensibility schizophrenia -- Despite Eclipse being extensible through plugins, those were really envisioned as third-party shippable modules. User configuration was a separate second-class sytem, entirely GUI-managed, and a major pain to clone to a new system. Compare to how Emacs & Vim work with a VCS-managed home directory, or even just a zip file or tarball. In no small part, this came from Eclipse's foundations on an early Java/JVM compiled-only mindset. With no scriptability baked into that platform, there was little choice but to have a strong divide between code (plugin) vs. data (configuration).

~~~
alblue
Projects can live outside the workspace without issue. Perhaps you haven't
used Eclipse in over a decade?

~~~
saidajigumi
Yes, you can place stuff outside the workspace, and I've done that. It feels
like you're fighting the system. And the fact of the Workspace's existence
still means that it adds pointless workflow machinations and cognitive load to
Eclipse users for no benefit, at least to those who aren't building (nearly
obligatory) multi-project workspaces for Java software. The very existence of
the Workspace has helped reinforce that useful, trivial actions such as
command line invocations don't even make sense to Eclipse:

    
    
        eclipse foo.md  # NOPE!
        
        eclipse /path/to/my_rails_thing   # NOPE!
    

'man eclipse' is telling:

    
    
        eclipse [ platform options ] [ -vmargs [ Java VM Arguments ]]
    

Read through "platform options" and the intent becomes clear: you're starting
a black box, not wielding a tool.

This is all really unfortunate, since Eclipse became home to the first (to my
knowledge) open-source platform for a wide range of AST-aware language tools,
and all the power those can enable. These often grew up with alternative
language implementations on the JVM. Other extensible development editors are
still largely stuck with some flavor of regexp soup and/or a cobbled-together
pot of external tools with widely varying performance, usability, and UI.

------
laveur
Good let it fall to the wayside while better tools come along.

------
landryraccoon
Suppose you have a hard requirement that your tools are free and open source.
What IDE would you recommend as a replacement for Eclipse? (JetBrains is out,
it's neither free nor open source). The worry I have with Eclipse dying is
that there isn't a great completely open alternative.

~~~
douche
There is a community edition of IntelliJ that is open source
[https://github.com/JetBrains/intellij-
community](https://github.com/JetBrains/intellij-community)

~~~
landryraccoon
Do you know if there is a python plugin for the open source edition?

~~~
alblue
No, there is not. The community edition of IntelliJ only supports basic Java
development (no JavaScript or other languages).

------
vvanders
Required: [http://theprofoundprogrammer.com/post/29839282968/text-
ive-g...](http://theprofoundprogrammer.com/post/29839282968/text-ive-got-
ninety-nine-problems-and-eclipse)

------
agumonkey
Eclipse is Emacs done wrong.

ps: oops, that was meant to be an answer for
[https://news.ycombinator.com/item?id=10274067](https://news.ycombinator.com/item?id=10274067)

~~~
tonyarkles
I've chuckled a few times in this discussion where people have been asking
"Have you tried Eclipse on an SSD?" Know what makes an IDE work even better
than an SSD? Being able to fit the entire thing in RAM and not have to page
out all the time.

Other than the speed part, the main reason I keep using Emacs is because of
the easy-to-access-remotely part of it. I've got a nice beefy Linux box at
home that I can ssh into. Tmux keeps my sessions alive. Emacs lets me do all
of the code editing. And the nice little Surface 3 is easy to carry around and
makes a fantastic SSH terminal.

~~~
agumonkey
Emacs isn't perfect, and Emacs was the Eclipse of its day.

But it makes a lot of sense so many times. Very pragmatic, extensible simply.
It's still thin spaghetti compared to the "sturdiness" of Java/Eclipse. But
I've seen the internal long time ago and it was just a fatter model of
spaghetti.

Anything in Eclipse requires a lot of efforts, and too many times the original
goal gets diluted in the implementation. I said it elsewhere, after spending
2004-2007 on Eclipse, then leaving for Emacs, I recently had to go back to
Eclipse, it's not better, git integration is useless, lots of windows for no
reason, a very special kind of UI, maybe suitable for people that likes
windows and mouse.

It's sad because it comes from the same community that creates the most job
friendly systems, so if you wanna play with JEE/Maven/EMF/..., you'll end up
needing something like Eclipse, because of this subtle synergy.

------
PaulHoule
Yes.

I know a lot of iOS developers that hate development for Android and I think
Eclipse is a major reason. Unlike Linuxers, Macers know that a good user
interface is possible thus they can't put up with the crashing, slowness,
pluginitis,...

~~~
forgottenpass
>$us have $good_property, $they don't even know $good_property can exist.

Thanks for the insightful analysis.

------
alistproducer2
eclipse for java. notepadd++ for js and php. moving to android studio, but
it's been pianful so far.

------
spiralpolitik
Eclipse teaches developers so many bad habits that I will be quite happy for
it to die in the fire.

~~~
ljk
been using eclipse since in school so never thought about it, but what are the
bad habits?

~~~
spiralpolitik
Two examples:

\- Dependencies between modules in the same source base for one, which given
the most common setup (single workspace) Eclipse will quite happily ignore and
treat everything as one module.

\- The default static analysis setup misses so many common things (unused
imports, methods, variables) that whenever I open a class in IntelliJ I have
to spend 5 minutes removing the cruft.

In its time Eclipse was a good IDE, but its time has passed.

~~~
anthonybsd
> Dependencies between modules in the same source base for one, which given
> the most common setup (single workspace) Eclipse will quite happily ignore
> and treat everything as one module.

Wait what? I have no idea what you are talking about. If modules are depending
upon each other via Maven, you simply stick dependant one to the other's
classpath if you want to use the workspace version.

> The default static analysis setup misses so many common things (unused
> imports, methods, variables) that whenever I open a class in IntelliJ I have
> to spend 5 minutes removing the cruft.

I'm looking at the same project here side by side and once again I'm not sure
what you are referring to. If anything, some of IntelliJ assumptions for code
quality can actually result in more fragile code if you aren't careful.

------
lolive
Do you realize that some people are coding Javascript (sic) in Notepad (sic)?
So please, let's be serious. Eclipse (and IntelliJ, and Netbeans) are f.cking
AWESOME productivity tools !!!!

