[kamilafsar]

A few months ago I tried Rust but found that the tooling like auto completion and highlighting where still a bit alpha. IIRC I used VSCode with the most popular Rust plugin at the time.

Did I miss something or is there some progress being made in that respect?

[praveenperera]

Yes sounds like you used the older RLS plugin. Which currently has 717K installs.

Try the newer and future default plugin, rust-analyzer (currently only 110K installs).

It’s much better and improving each week. With RA and VSCode the rust developer experience is fantastic.

Link: https://marketplace.visualstudio.com/items?itemName=matklad....

[hobofan]

Sounds a bit strange. I'm using rust-analyzer in combination with TabNine (which both have integrations in every major editor), and it's among the best completion I've encountered across languages (though there are some limitations when it comes to proc-macros).

Maybe it was still downloading some required binaries in the background when you were trying it out?

[trevyn]

I’d love to see an open-source clone of TabNine.

[ameixaseca]

I don't want this to sound like a criticism, but I would like to understand your point of view: do you really consider this a reason for choosing a language over any other?

Even if you had to use notepad to program - or had very basic syntax highlighting - wouldn't be what the language provides a more compelling point to make these choices?

[seabird]

Absolutely. I don't think developer ergonomics should take priority over absolutely everything (the modern web arena shows why this is bad) but there are some great technologies that have lost out or are relegated to incredibly niche use cases because their ergonomics are bad to the point where you just can't afford to deal with them unless you really have to.

Ada/SPARK/Ravenscar are a perfect example -- they provide incredibly powerful tools for proven correct programming. They are open source. The ergonomics are nowhere near what you're probably used to having, and that's why odds are very high you've never used them.

[tetha]

I'm currently working myself into rust, and yes, it is certainly a mighty inconvenience. Probably of my setup, I can't tell yet.

In java with a good IDE, you can ^Space yourself through a lot of problems without knowing the libraries too much. And even if you don't just pick the first thing sounding right, scrolling through the documentation of the auto suggested methods is very convenient.

On the other hand, my dev-laptop currently has about 20 different rust-doc pages open at the moment to keep track of ... the methods Iter<T> has, the methods IterTools has, Vec has, Slices have, what package FromStr was in again, what methods a str::fmt::Formatter has to implement Display to implement Error (that needs to be imported), where HashMap is, what methods those have...

I've been there multiple times over the last decade or two with multiple languages and rust is compelling enough to work through that.

But if you compare the ergonomics of modern java, go or python IDEs with my current vscode+rust-analyze state, rust isn't winning on IDE ergonomics. At least in my setup.

And that's very much a part of language choice.

[tetha]

Since I got a bit engaged there, this has led to my lesson of rust today. Or, the first one: There is the "rust" extension for vscode. This extension can be configured to use rust-analyzer as it's backend and I figured that was what people meant with "use rust-analyzer".

However, there is an extension called "rust-analyzer" and from a few hours of writing rust, it's so much better. Inline type annotations, good type ahead and completion.

[steveklabnik]

There are a lot of people for who this is true, yes. It has come up consistently on our annual survey.

Usability is a feature, and many people consider a language’s IDE support to be a critical aspect of usability.

[mlindner]

It's certainly an interesting position, from my perspective, as I (and probably OP) have worked our entire professional lives without a syntax checker or any other form of IDE other than simple things like autoindent.

[steveklabnik]

Yes. I too have been pretty anti-IDE most of my history. But I think a lot of it comes down to tools and culture; Ruby (which I have done for the first half of my profesional life) is extremely hard to give good tooling for. So the tools are bad, so they aren't useful. So you don't use them.

Contrast with a language like Java, which is very amenable to a lot of tooling, and kinda sorta needs it to make the language more usable. If that's your background, you can't imagine not having that tooling, because, well, you're used to it.

I will say that I have been playing around with using more IDE-like things, and even though it's culturally pretty foreign to me, I understand the appeal. And as I'm getting more used to it, I get annoyed when it's not there, and then remember how I used to pooh pooh people who required all those fancy features. So... I get it. These days at least.

[kamilafsar]

The gap between classic IDE’s like XCode, Visual Studio or JetBrain’s IDEs and text editors are getting smaller each day.

I’m not keen on the classic IDE experience either. I like VSCode because it’s a simple/light weight text editor which helps me with small tasks like auto-imports.

I feel like these things are especially helpful when you’re a beginner and just started learning a new language.

Anyways, thanks for the hard work Steve and I’ll give it a second try with RA soon!

[jiggawatts]

> I don't want this to sound like a criticism, but I would like to understand your point of view: do you really consider this a reason for choosing a language over any other?

Absolutely yes.

I no longer consider a programming language finished unless it has at least tab-complete and proper debugging support. Inline popup doc-comments are nearly mandatory too.

Not designing a new language for modern tooling is a cardinal sin. It's giving up decades of progress for... what exactly? Some sort of ascetic purity?

One disappointing design aspect of Rust specifically is that it has a tendency to "hide" functions unless explicitly imported. This makes things difficult for IDE tab-completion. It gives the false impression that some functions are missing, when in fact they were simply not imported into scope.

The language seems to be designed for developers that know ahead of time what they will or will not use, to the finest detail, before they even start typing code.

I've only ever met one programmer that could do that: start at the top of the file and type continuously, left-to-right and top-to-bottom without editing, without pause, without having to go back and fill in anything he had missed. Let's just say he was a "special sort" and leave it at that.

The rest of us are much more productive with IDEs and debuggers.

[Ar-Curunir]

Once you get to larger programs, having nice tooling for things like language-aware autocomplete, language-aware refactoring, etc is an absolute must. It reduces the amount of time spent on the manual labour, allowing you to actually think about the problem at hand

[stusmall]

As others have said, I'd be curious what plug in you use. The state of things is pretty good. I'm using the IntelliJ Rust plugin and love it. It also provides pretty good inline annotation of inferred types which I find to be a big time saver.

[heavyset_go]

I use Kate, which is really bare bones, with a Rust LSP server and haven't had a problem with completion or highlighting.

[steveklabnik]

rust-analyzer gets better and better every week.

[ZeroCool2u]

CLion with the Rust plugin is pretty great.

[rsynnott]

The IntelliJ plugin is pretty good.

[laszlokorte]

not sure which plugin you used but rust-analyzer is the way to go.