New Photon Release of Eclipse IDE Ships with Full Rust Support | Hacker News Reader

New Photon Release of Eclipse IDE Ships with Full Rust Support

eclipse.org

79 pointsconductor43 comments

Open articleView on HN

EDIT: Found it under the "New and Newsworthy" button [6].

The lack of feature list and screenshots in the "new" Eclipse Photon page is astonishing [1].

Compare that with the landing page for Xcode [2], SublimeText [3], Visual Studio Code [4] and/or Atom [5].

They need a better marketing team if they want to appeal to the young programmers looking for a real IDE.

[1] https://www.eclipse.org/photon/

[2] https://developer.apple.com/xcode/

[3] https://www.sublimetext.com

[4] https://code.visualstudio.com

[5] https://atom.io

[6] https://www.eclipse.org/photon/noteworthy/index.php

Haven't tried Rust with Eclipse, but the IntelliJ rust plugin [0] is already quite good and getting better on a weekly basis. Most things work in community (free) IntelliJ, and with CLion you also get pretty a pretty solid debugger UI.

[0] https://intellij-rust.github.io/

I like the JetBrains IDEs, but the Rust support will likely become a paid feature in the future. Go support was free while it was being developed, but the Go plugin is now only for the Ultimate Edition.

It's MIT licensed. It's not clear to me that it's developed by jetbrains at all, but if it is, there will probably always be an open source version, if only because it gets forked.

I believe there is some ‘official’ support for that plugin, I vaguely remember reading that JetBrains was devoting a small amount of resources to aid in its development. Though I can’t imagine it would effect the license

The author of the plugin works at JetBrains and works on it on his day job.

The Go plugin wasn't open source, right?

The plugin already has paid features in the sense that the debugging support only works in CLion. That seems like a likely future path to me.

maybe it's just me but method completion (intellisense or whatever) isn't very good.

Surprisingly, switch from IntelliJ Rust to Rust extension for Visual Studio Code improved my experience. Mostly the error box.

I got Rust working in Eclipse in just a few minutes, most of which was installing Rust.

After using Eclipse for C++ (CDT) off and on for a while now. I've come to the conclusion that when set up properly there's no better C++ tagging system (F3 Open Declaration) and auto-complete in any IDE except perhaps Visual Studio. It works so well that people like myself who dislike Java still use it on C++ projects out of the sheer advantage it gives you when browsing through a code base. I don't know what they've been up to there on the CDT project, but they sure have managed to get it right.

Do you dislike programing in Java, or using programs written in Java?

Generally Java has a large footprint on the machine and startup time can be slower (however they're attempting to solve through the Graal VM). Also Java's syntax is extremely verbose and the API usage is verbose as well. All common complaints coming from a C++ programmer. When comparing programs for daily use, native applications tend to feel snappier, though there's no reason a Java program can't feel that way if properly written.

I like Java for the comfy warm embrace that a business language provides, but C++ wins out in the world of 'get out of my way and let me get stuff done'.

C++ wins out in the world of “get out of my way and let me shoot my feet off”. The only professional language hated more than Java is C++.

You're not wrong. This is a Rust post after all. I'm of the opinion that C++ by itself is both unfinished and bloated at the same time. Most memory access should be funneled through libraries better equipped to handle memory than our feeble minds, and when we really need the performance, we know when to break out of the cage and get things working. Most of the problems I've encountered in C++ is interpreting the crazy stuff other developers have done, because alas C++ has allowed it! Funny enough, the object oriented nature of the language has been the biggest thorn in my side. You'll get no shortage of complaints by me of how C++ is designed. Somehow I manage to forgive a lot due to the incredible performance of the code a C++ compiler generates.

I used to think that before I tried using Qt Creator. Your project doesn't need to be a Qt project for you to use it. Make sure you enable the clang code model plugin. It's a bit slow but otherwise flawless.

Certainly willing to give it a try. I can say that I can't imagine any tagging system to be any better than CDT, so at best it may be comparable. Though if the system is comparable with an interface that's faster than Eclipse, it would be quite nice.

Having used both, Qt Creator is so much better than eclipse that it's not even funny. Of course, you first have to forget your eclipse habits and learn the equivalent QtC ones - in particular using the locator (http://doc.qt.io/qtcreator/creator-editor-locator.html), and the available refactorings (http://doc.qt.io/qtcreator/creator-editor-refactoring.html). Recent versions also ship with a clang backend for completion ; it also supports clang-format and clang-tidy natively, with inline fix-its that are shown automatically.

Qt blog has quite a few complaints regarding completion performance delays on Windows from several seconds.

Opinions vary on QT Creator. I personally found it to be hostile to my desires. The little thing that made it unfit for my purpose was that, when I code for Cygwin use, I need my Windows editor to be configurable for Unix conventions, but QT Creator was not configurable to Unix conventions. Eclipse is configurable.

I believe if I had been making programs targeting QT, I might not have run into this issue. But I don't make that kind of program.

I tried out Qt Creator and I have to say I'm impressed. Once set up I can say that the tagging/autocomplete worked quite nicely. Very snappy.

How is eclipse in 2018? For many years, I loathed working in it, but it might have improved in the intervening years. I've paid for intellij for a long time, but I remember daily crashes and 5 minute boot times for the springsource flavor (needed to work with grails.)

The Oxygen release works quite well for me. Sure, it could be a little faster to startup, but I don't know many IDE's I wouldn't say that about. Functionality wise though, I don't think it's ever outright crashed on me, and all the features I need are there (or have plugins).

Call me old-fashioned if you will, but I still prefer Eclipse to any other IDE. That said, I stick to "vanilla" Eclipse plus a handful of hand selected plugins. I try to avoid vendor-built versions like STS, anything branded "WebSphere", etc.

Note that if you use the latest version of Grails, you no longer really need a dedicated Grails plugin for Eclipse. Use the Groovy plugin, Gradle plugin, and the standard HTML editor and you get pretty much everything except for perfect highlighting, and code completion, in GSP files.

Plain-jane Eclipse works better for me than IDEA for my hobby Java coding. On my late 2015 Mac, Eclipse much snappier and the font-rendering is better. IDAE takes 3+ mins to launch. Eclipse takes 20s on a cold launch. To be fair I am not using any plugins and not doing any JEE stuff.

I just can't get IDEA to respond to clicks in less than 10s. There's obviously something wrong with my setup.

I have that problem in IDEA if I enable 1) IDEAvim, 2) ligatures, and 3) relative line numbers.

That may be idiosyncratic but if you happen to match, there you go. Either turn off relative line numbers (absolute are fine) or ligatures.

I'll give that a try. Thanks.

Sure thing. Going from relative to absolute took my startup time down from holy crap to a couple of seconds and eliminated a bunch of pause/stutter after code changes, especially with large files. Started right when I moved to Fira Code, and took me forever to find the footnote in a random GH issue (think in the IdeaVIM repo, but might have been the Nerd Fonts repo) that mentioned the behavior.

Lack of a great command palette was a big one. It is how I do everything in vscode.

However, after being frustrated for long enough, it motivated me to make my own that is more of modern command palette for Eclipse.

https://github.com/dakaraphi/eclipse-plugin-commander

Using InteliJ due to Kotlin and Android made me enjoy using Eclipse again, specially on middle specs laptops.

It's great to be honest. You have to just suck it up and learn is complexities and give the thing 2g of ram, but in return you get such a comprehensive and customisable at of features - every language in one IDE, incremental compile, etc.

Awesome. Can't wait to give this a try. I haven't done much with Rust yet (just "Hello, World" basically), but I'm an Eclipse user, so this will be handy. Having solid Rust support in my favored IDE will reduce the friction to using Rust a little bit at least.

Well, not a great start - the console is throwing Java exceptions, and when I ask for a code completion, it just spins for a while and eventually fails.

I'll continue to poke at this, I think. For me, the competition is Sublime Text with a bunch of Rust plugins. It took a while to set up and it's not super snappy, but it works decently. I would like to replace this setup with something more "out of the box" and better integrated.

For anyone interested in rust IDE, maybe check out https://areweideyet.com/

And if you are looking to get into Rust, The Rust Programming Language by No Starch Press is just out: https://nostarch.com/Rust

I think the same guys published it here for free:

https://github.com/rust-lang/book/tree/master/2018-edition/s...

Yes; it’s rendered here: https://doc.rust-lang.org/stable/book/second-edition/

The contents may be the same, but the physical book is way nicer, IMHO. I happen to love physical books, though... and the PDF is much nicer than our current “click print to PDF” solution.

Is this is using LSP, and therefore RLS, I hope it doesn't suffer from the constant silent aborts I get using the Rust plugin on VSCode. Everything is nice and fluid with Auto complete, error and warning tagging, and definition-on-hover, and then BAM it just stops with nothing to explain when, how, or why. Restarting RLS does nothing, and closing and reopening the workspace might work but there is no guarantee.

How's it working here and in IntelliJ(which I've been using for Scala and Dart for sometime, but feels heavy)?

There have certainly been some serious stability bugs lately, but we’re also working on fixing them. Please file bugs!

Thanks for all of your work! I realized how gripe-y this sounded coming back and reading it now.

I also would like to mention, that I updated this evening and found it to be much more stable, even if sometimes it hiccups for a minute or two. I think actually turning off VSCode's word-based auto-complete for Rust files will help, as I won't get false positives.

AFAIK the IntelliJ Rust plugin does not use the RLS, but uses an in-house solution.

Completion works very well, Error reporting however is good but painfully slow.

It does not use the RLS, that’s correct.

Excellent! Sounds like some great improvements on top of an already amazing tool. I have to say that they've really come back from some serious missteps a few years ago.

Rust? The big news here is support for the Language Server Protocol! Now, finally the UI of IDE would be decoupled from the language service.

Reply on news.ycombinator.com