Eclipse IDE 2021-03 | Hacker News Reader

Eclipse IDE 2021-03

eclipse.org

99 pointspjmlp92 comments

I can say one thing in favor of Eclipse. Out of the box, it would show you compile errors across your whole Java project, so you could do interface refactors and method renames fearlessly.

In Intellij, for years and years and years and years and years, and possibly even still, you had to enable a changing and unpredictable set of options to get the same set of behavior, maybe. You'd try to find the most recently edited answer in this question[1] and hope that it worked. Note how one of the upvoted suggestions is "use the Eclipse compiler instead."

So yeah, switching to Intellij killed off like 30% of what made Java development bearable for me.

[1] https://stackoverflow.com/questions/19364949/how-to-view-the...

As an IntelliJ user since 2003 I've heard this comment from Eclipse users multiple times, and always been puzzled about it. I think there is an IntelliJ "problems view" or something like it.. but in my entire career I don't think I ever looked for it. I could run a build whenever I wanted to find out if things were broken in some way. When it came to refactoring, renames, etc, I felt empowered with IntelliJ to safely do those with their refactoring tools in way which Eclipse was a very slow follower.

I suspect there are two components to the Eclipse vs IntelliJ bias in folks. 1st is which IDE they used first, and like every editor war, this is all about habit and finding that the workflow you built around one tool doesn't fit another, and then the second is about which phase you adopted the tool in. IntelliJ was so far ahead of Eclipse in terms of pure usability and delightful advanced completion and refactoring features in the early days, but eventually Eclipse - and other IDEs which will not be named - took inspiration from Jetbrains innovation to narrow the gap.

You can ask IntelliJ to analyze your code and then it will tell you the places where a method could be static, for example. As far as I know the Java compiler doesn’t warn about this. So building the project will not tell you.

Eclipse has a “problems” view which shows you all these kinds of problems across your whole workspace, all the time. I find that to be very nice: you configure Eclipse to show you the kinds of warnings you care about. Then you get a list of places to fix. And you can make sure that the list is empty at all times.

In IntelliJ you have to start analysis, and the CPU fan spins up and it takes some minutes. And then the list of problems goes away after a while and you have to rerun analysis.

In IntelliJ I make do with the annotations in the file I’m currently editing. IntelliJ also has smarter warnings than Eclipse does. But still, the problems view is very nice and I miss it.

Not sure how properly implemented refactoring would lead to compile errors that were not there before (maybe due to some Spring configurations or @Annotations not being considered?)

My usual pain point with eclipse was mostly package refactoring always leading to tree conflicts with SVN repos.

But that was ages ago and back then using Idea was way ahead of eclipse wrt refactoring and overall developer experience/productivity for us.

I'm sure Intellij is very nice with refactors that just push code around. Renaming or extracting a method in an automated way should obviously maintain working state.

But I'm not religious about TDD. I might try different ways to modularize the same code or sketch out several different interfaces or service stubs. This is not something that you can automate.

And when I'm done laying out the major pieces, the problems view in Eclipse helps me climb out of the sea of red that I've created by pointing out where I need to wire up methods together, or think more about type signatures, or whatever.

Tangentially, this is why we chose Dagger over Guice for dependency injection in Java. Dagger generates the wiring code at compile time, so you get all the niceties of static type checking in plain view, right away.

Thanks for the clarification. I understand it's more about "exploratory" refactoring.

Thinking further I might have silently adopted a self-imposed "keep track of edit states and memoization in the wetware stack" approach, which I realize now is something that is far more exhausting than offloading to the tools whose purpose it is to show where the missing bits are.

I thank InteliJ for making me love Eclipse again.

Been using Eclipse for 10 years. On big Enterprise multi-module maven projects. For Java + Maven, everything just works. The number of plug-ins it comes with simply outstanding.

However, I want Compiler Compliance level setting not be drop down any more, as Java release cycle has changed. I like to play around with cutting edge. Few days back, I downloaded Open JDK project loom 17 release to play around with Virtual Thread a.k.a Fibers and there was no option to set it to 17. I tried LSP Redhat plug-in in VSCode, but it also gives Invalid runtime JDK warning.

I'll continue using Eclipse.

Eclipse is amazing. The built in Java-compiler and the error-tolerant editor is so awesome.

There's been periods where it has been so buggy that it's been nearly unusable and just a very rough ride, but for the past few (three-four?) years, it just works.

What’s an error tolerant editor?

An editor which is able to do meaningful semantic analysis of code which contains errors.

Love Eclipse and I'm a regular donor to the foundation.

The most important tool is the one you know how to use though. If you can't run your unit tests in your IDE, or you don't know how to launch an embedded server, or take advantage of the key bindings and type-ahead, then you're missing the point and you'd be better off with vim or notepad. The point of an IDE is you're commanding it to do large parts of the work for you.

A little bit ago I tried to revive some old Java code by downloading Eclipse and trying to use it again. I can’t believe it’s improved so little UI/UX compared to 10 years ago, and still had what felt like all these weird behaviors like forcing me into a workspace. I actually was getting enough strange errors that I couldn’t figure out how to deal with I just ended up porting the code in Python using VSCode. Granted I’m sure with enough googling I could have figured it out, but it didn’t seem worth it. I used to love eclipse back in the day— those days are long gone.

Eclipse (and any IDE for the matter) is an incredibly complex piece of software.

I don't think it's reasonable to say Eclipse is bad because you haven't used it for 10 years and had trouble finding your way around, etc. The same could be said about Visual Studio, VSCode, IntelliJ or whatever else someone wants to program with today.

I don't think that's true. I used Emacs for a couple of decades, then decided to try VS Code one day and was productive and comfortable in a couple of hours. My first impression of it was "oh, a programming editor with some options I can ignore for now".

Exactly, VS Code is just an editor, a very good editor. In fact Java language support is provided by headless Eclipse integrated with Visual Studio Code via the Language Server Protocol (LSP) (just google visual studio code java headless eclipse)

As an alternate anecdote, I spent hours trying to figure out how to compile some basic C code in VSCode - neck deep in configurations and hidden menus with special button combinations, etc - only to break down and install some random plugin.

The point is, any new environment is going to be jarring at first. You have to learn how to use your IDE - and once your do, productivity can go way up (this is why people do not switch IDE's very often, you must invest in your IDE to master it). Every IDE has different productivity-enhancing features (beyond basic code suggestions and auto-complete).

If you can master a brand new (to you) IDE in minutes, then it's frankly not a very powerful IDE. The basics, like refactor some code, move some source files around, create a new file, etc - sure, those should come easy. Things that don't come easy is how to create new file templates, enforce code styling, configure database connections (if you work that way, I don't), how to package your software, and the plethora of other things IDE's do for us these days.

VSCode, being a text editor, of course would need some random plugins to behave like a IDE (i.e. compile some basic C code).

You can prefer an IDE, or a text editor + plugins. Either would be fair.

But the complaint that text editor without plugins doesn't "compile" your C code is misdirected.

I don't think you can call VSCode a text editor. Their own website champions IntelliSense, Debugging, and Built-in Git for starters. That sounds like an Integrated Development Environment to me...

We've strayed from the initial point - IDE's are complicated because they do complicated things. Any new IDE is going to be difficult to use at first, unless all you need is the absolute basics (a la text editor). Criticizing Eclipse for not knowing how to use it after 10 years (effectively using it for the first time I'd argue) is definitely unfair.

You said it's not reasonable for someone who hasn't used a certain IDE for 10 years to be able to navigate around in it easily. I countered that VS Code was very easy for me to find my way around even though I'd never used it.

For giggles, I just installed Eclipse for the very first time on this computer. I opened a Python file, and it's visible in the middle third of the window, surrounded by wide sidebars and a bottom section with labels like "Markers", "Servers", "Data Source Explorer", and so on [0]. I have literally no idea what I'm supposed to do next, or how to fix that I can only see a tiny bit of my code by default. Contrast with opening a file in a brand new, unconfigured VS Code setup [1].

I'm not saying that Eclipse is bad, just that I don't know how to use it. That's not a criticism of it. However, I strongly thing that the first-time experience of opening VS Code is miles better than that of Eclipse, and I guess I am criticizing that a little bit.

[0] https://imgur.com/a/ImVGDgN

[1] https://imgur.com/I34NT9r

We can nitpick this all we want - because in your VSCode screenshot I do not see where I can add a new file, or rename my open file, or create a project structure, etc.

In your Eclipse screenshot, it seems pretty obvious you can click-drag the window to be larger.

So, what is it we're arguing about then, if we both agree a default UI layout isn't indicative of a good or bad IDE?

I'd wager if you spent a few hours in Eclipse you'd feel comfortable navigating your project too. AKA, invest the time and learn the tool you will be using.

Generally agreed but I still think its navigation isn't good.

source: I should use Eclipse at work for a few years

As a daily user I'm glad that eclipse is still around. After so many of my colleagues switched I tried to use Intellij for Java+Maven projects twice in earnest, but there were too many small things it felt like it did not quite as well.

Out of curiosity, what were a few of those small things?

Options dialog (shift+shift) would populate candidates at different time intervals and push the list around such that if you saw an option you wanted immediately and down+enter it would do the wrong thing.

Recompiling after a save would unshow/show method parameter names (which didn't change) in function calls which again pushes text around that one may be reading/interacting with.

Variable insertion (ctrl+alt+v?) was too heavy, I shouldn't need to wait for a dialog to pop up.

Mouseover didn't show actual types for things--only the javadoc--and required a key binding to show the actual types.

Running a single test required recompiling for some reason and wasn't instant.

Debugger doesn't show variable representation for long values well and makes you pop up another dialog.

Even though it uses the same terminology the debugger tries to 'help' by making 'step into' more like "maybe step into if I think that's what you want, otherwise I'm going to step over even though there's a separate key for that"

Huge tooltips constantly popping up as I'm typing things, obscuring lines above that I may be trying to read eg. variable names.

Can't have multiple projects open.

No way to make the outline/structure show program order. Someone asked in a ticket for this is the devs made them justify why they wanted to see their code in the same order they wrote it, and then still didn't fix it.

They have mini modes for things like json that make the editor experience actually just worse than typing in notepad. Don't insert commas when I hit enter and make the json invalid. Don't try to help me type escape sequences in a single string and produce "\"","" whatever that is.

I was a strong Eclipse supporter, I'd always advocate Eclipse at work (vs IntelliJ) ... but eventually I had to give up. The maven integration was breaking with each release. Not to mention the often half broken, incompatible plugins that would make the IDE unstable.

Switched to IntelliJ and never went back.

Also: IntelliJ's superior scala support also played a huge role in the decision.

I still use Eclipse and have no complaints. If IntelliJ was a one time payment, I might give it a try, but I really dislike being bound to a thing with recurring costs.

I've used IntelliJ for a JavaScript project and in the form of AndroidStudio, but I don't remember anything so extraordinary that it would compel me to switch.

I am not in any sense affiliated with IntelliJ. I also resent recurring costs. But I am willing to throw ;-) an exception with them, because their development cycle is fairly strong and fast, so you get meaningful updates even during a single year.

IntelliJ actually is a one time payment.

Any 12 months subscription (be it one payment annual subscription or 12 consecutive payments) allows you to keep the current version forever. The subscription is only needed if you want to update to a newer version.

https://sales.jetbrains.com/hc/en-gb/articles/207240845-What...

For me—apart from the UX/UI—it’s the refactoring tools where JetBrains products shine. They work best with statically typed languages, however.

Maybe for Non-Java languages IntelliJ has an edge? When I used it, it was doing JavaScript for a company and all the other devs were absolute fans.

I haven't really missed much with Java development on Eclipse.

Downloaded it, tried it to build some C++ code, with a few requirements. It has to work with C++17 style code to use on an existing codebase. It should use clang + llvm instead of g++. I want to use the clangd language server (or ccls) with eclipse, probably via a plugin.

Even something this fundamental took me a fair bit of searching through forums and is turning out to be a hot mess.

With Xcode, IntelliJ and CLion, and heck even VSCode, things just work for me. Key bindings make sense. Common options are available and where you'd expect them to be. There's actual "flow" in my workflow instead of having to battle with the tools.

IMHO Eclipse tries to be everything and the kitchen sink, and it's getting increasingly hard(er) to get set up and use productively.

I always feel that Eclipse is Foss but mainly supported by large corporations who put real improvements first in their commercial version. When I see eclipse, I directly think big blue’s toy project. But the basic IDE is still feature complete, but lacks the real needed innovations imho.

Having an Eclipse release sit on HN for 3 hours with zero comments seems like the most accurate depiction of the market's current feelings towards Eclipse...

Plenty of people use Eclipse for their daily-driver. 2021-03 has been out for merely hours and already has clocked up over 11K downloads[1]. That, of course, doesn't count all the people happily using a previous version.

Eclipse itself has certainly improved dramatically in the last couple years. Speed, UI, Installation, etc. Lots of polish going into it...

[1] https://www.eclipse.org/downloads/packages/

>Having an Eclipse release sit on HN for 3 hours with zero comments seems like the most accurate depiction of the market's current feelings towards Eclipse...

This is a really strange observation.

Do a search here on HN for the Visual Studio Code editor and you'll find a number of posts with 0 comments. I use that editor as an example as it seems to be among what's popular at the moment.

I don't think you can derive much from the number of comments a post has after 3 hours. Some of the more popular posts on HN exist after the link had been submitted a number of times prior.

Not really. Eclipse has been my daily driver for python and web development the past 12 years. Every time I try another IDE, I find myself missing features that PyDev does so well, and end up going back.

That's actually par for the course for a lot of Java content, and that's ok.

I'm not the youngest developer, and I like to see content on my steady bread-winner so I upvote it. Java is in a mature phase, so there are not a lot of surprises, and things to discuss. Even the shiny new things that make the platform unique like Loom have been years in the making.

Just Java being Java, where 'boring' is what you actually want from it.

Happy Eclipse and NetBeans user for what concerns Java development.

I rather suck it up and use Electron for Java development (VSCode + Microsoft/Red-Hat plugins) than having to deal with InteliJ.

Well then, good news! Jetbrains Projector enables Swing apps to run as Electron apps: https://lp.jetbrains.com/projector/

How do you even find that on their website? I don't see it anywhere!

It was announced on the blog (https://blog.jetbrains.com/blog/2021/03/11/projector-is-out/). The actual website is surprisingly tricky to find, doesn't seem to have climbed google indices yet.

You missed the point that I have to be paid to use InteliJ.

No, I got that you don't like either IntelliJ or VS Code. But I saw the narrow gap for a joke and decided to wiggle through.

Any recent (2y) Eclipse release with Darkest Dark theme is pretty good for me. Tried Intellij, VS Code... still prefer Eclipse. Maybe I'm just getting old.

boring == stable, and I'm perfectly fine with that for serious projects. I'll leave to hipsters to pave new paths, and I'm going to learn from their mistakes ;)

Lol at this point we are way past hipsters paving new paths. The paths are established and have been for awhile.

> The paths are established and have been for awhile

I'd rather say that old paths keep getting rediscovered. Such is the cyclic way of tech. There are always new "hipsters" that are freshly paving old paths, putting their unique spin on it.

Agreed. I wouldn't be surprised to see Eclipse come back into fashion in a couple years :D. Maybe in the form of Che. Who knows. Things come and go.

Speaks like a true foot soldier. I'm very grateful for your service; we always need fresh meat :D

Same as every Clojure post.

Is there a use case for Eclipse that VS/VSC doesn’t outperform it at?

Yes, not having to install and integrate 5-6 workflow plugins of questionable provenance to have acceptable devex out of the box.

How are you able to use Eclipse without installing 5-6 plugins of questionable provenance and quality?

Because Eclipse is an IDE, and at least for Java, it just works out of the box with default configuration. And that includes popular build tool integration, code execution, step-through debugging, version control, and a bunch of other stuff.

In the world of VSC, this stuff requires figuring out which tool the community recommends, configuring it, and making sure that all the things you chose actually work together.

My first and only interaction with Java was a short project. I installed Eclipse and had a prototype with GUI at the end of the day. I was an inexperienced programmer with zero Java experience at the start of the day, and I credit Eclipse with much of my onboarding.

embedded developement full blown ides. almost all of them are eclipse bundles and reskins. except microchip mplabx, which is netbeans.

there is platformio for vscode in same vane but kind of a hodgepodge dog

I had to pull a all nighter on my personal machine to impress a job prospect. The project was in a mix of java/scala, I use both at work with Eclipse on my work machine.

On a whim, I decided to give VsCode a spin, since I don't code java for fun there was no IDE for it on my personal machine.

I spent the night pesting at VsCode. Many very basic things require a plugin, and some are not present.

Will not use again to do Java. I like it for python.

Defense industry.

Refactoring?

Speeding up Maven compiles?

a complex project where there is multiple maven projects

R with StatET?

IntelliJ is probably the better comparison. It's not free, but for $100/year or whatever it is, it's worth it to not have to use Eclipse.

So why pay for turning the laptop into an airplane getting ready for take off, lack of incremental compilation, no support for mixed language debugging with JNI, 10 key combos, having to explicitly search issues (inspections), no javadoc tooltips by default?

None of that is accurate, in my experience of using it, but go on...

For those who don’t know: there is a free Apache licensed version of IntelliJ.

It’s usable for Java/scala development, but lacks features. Feature comparison at https://www.jetbrains.com/idea/features/editions_comparison_....

And “whatever it is” is $499 for the first, $399 for the second, and $299 for later years (https://www.jetbrains.com/idea/buy/#commercial?billing=yearl...)

That is the institutional pricing.

The individual price for Ultimate Edition is $149 the first year, $119 the second consecutive year, and $89 a year from then on.

>79.6 million lines of code

Amazing

That's just not true. I checked out the source code because I was curious; it's ‘only’ 7.9M loc. I would guess that somebody slipped an extra 0 in there by accident (though I'm still not sure how they got that number, because the true tale is smaller than 7.96M).

That number (79.6 MLOC) is gained by adding together all the projects that participates in this release, which is far more than just the Java IDE. For example the Eclipse Platform which all the Eclipse IDE's builds on top of. Now if you look at just one of the five git repositories that is part of the Java tools, eclipse.jdt.core, you will get 1,597,008 lines of code.

Why is it so big? Intellij is ~6 million lines of mostly java.

I would say Eclipse is more than just an IDE. Also, aggregation of OSS lumped together, rather than a comercial product?

If I'm not mistake dbeaver is eclipse based and it does a fabulous job of multi sql variant support. Being able to query MySQL, of, redshift, etc in one place is quite handy.

I preferred Eclipse to Intellij because it was free, and free meant that everyone based their software on it, and once you learned it, for example, if you knew Eclipse you knew the Scala IDE, the Salesforce IDE, Mulesoft, Teiid, Red Hat JBoss development, and many more.

VSCode has taken over the "everyone extends it" space. When you know your way around VSCode you're good to go on a lot of the software projects you work on today.

It must be a testament of how extensible eclipse is that I am here doing embedded/firmware development for SiLabs and ST micro-controllers and both of them (out of the box) use their own customized version of eclipse. It's gotten better but it's still painful even to just setup a dark theme that works w/o a lot of tweaking

I'm happy with IntelliJ (>9 years of ~daily use), but if there are long-term users of Eclipse here who are familiar with both and prefer it to IntelliJ, I'd be interested to hear why.

I now use IntelliJ (CE) but:

- Eclipse type hierarchy view (and quick view) was nice

- Google-Java-Format plugin integration was better

- The default color scheme of Eclipse was better (not sure why but I can't use a dark theme with Java)

But Eclipse had too much strange behaviors where I had to restart it and IntelliJ has those warnings/suggestion about code quality and better auto-completion IMO.

Yes! The type hierarchy view was great, forgotten about that.

I'd also be interested to hear this. I used to love Eclipse, but really didn't like the workspaces concept and endless wrangling with plugins that frequently broke something on minor updates.

I moved to intellij because the simple things I needed just worked out of the box, and I mostly find it great.

But I'd still like to hear from someone with a different take on it .

I haven't had to bother with workspace stuff in years because of Gradle. I know that not everyone uses Gradle, but it gives you an equivalent of `cargo init` or `npm init` to initialize an Eclipse or Intellij project in any filesystem location.

I loved eclipse for a long time.

After the next upgrade on arch linux where i had to fix the setup and reinstall some plugins/dependencies we switched to intellij.

Intellij just works :(

I use Eclipse CDT often. It's gotten gradually less painful and annoying over past years (and maybe I've done less to misconfigure it).

Maybe I'll try it again. The last time I used it (maybe 2013?) it was a hot mess. I spent an entire week with it to give it a fair shake, and it was terrible.

Consider trying it again, but make sure not to reuse an old workspace/project, since you'll be importing a bunch of hot mess :-)

I think I just really like the Eclipse's implementation of emacs keybinds. Various VSCode implementations can't seem to get it right.

What's a super-minimalist Eclipse configuration that's just good enough for Java development?

The Java IDE download of Eclipse - it's just the base IDE with all the Java addons. The editor is fantastic, I hate the rest of the design paradigm but I also hate IntelliJ's - it never clicked with me.

The quality of all the other addons are variable from amazing to trash (because there is a commercial version they'd rather you bought).

That was always the problem with Eclipse foundation - the struggle between what's free in the IDE and what's commercial and how to drive spenders towards the commercial solutions.

I wish they'd shown an image of the IDE in dark mode just to reset people's expectations and think that it could be different than they remember.

I haven't used it since the switch around 3.7 - 3.8 (aka 4.2).

I came up in the Java world using Eclipse exclusively for years working an a large enterprise code-base. One day someone convinced me to try the Intellij IDEA (Community Edition). Once I realized I could easily switch to the Eclipse keybindings it was all over.

Intellij is not perfect, but it is not nearly as "user-hostile" as Eclipse. Most things just work (without hours of fiddling). Updates to new versions just work. Dark themes just work. Honestly coding in Eclipse feels like a trip back in time after getting used to Intellij.

Except having two projects open in the same window.

TIL Eclipse still exists. Honestly I hadn’t heard anything about it in years.

I know it has (had?) fans but for me it’s model of perspectives where your entire UI changes when something happens never gelled with me (YMMV).

I can recall many conversations by colleagues who were stuck in plug-in hell with Eclipse. Different Subversion (then git) plugins that didn’t quite work in different ways. That sort of thing.

For 15+ years I have been (and remain) an IntelliJ fan boy.

Reply on news.ycombinator.com