Lack of IDE integration, Rust comparison to modern languages with respect to foundational theory, and possible fixes

[DrizztVD1]

Continuing the discussion from Rust beginner notes & questions:

Rust beginner notes & questions

The feedback I'm trying to express is that it doesn't feel like the typical learning curve. Keep in mind that I took to Haskell like a duck to water, and that's generally considered a relatively difficult language to learn. The link you referenced seems to cover at least some of the issues I've noted (yay!), but at the same time it feels like it's making things worse because it's yet more layers of ad-hoc magic and bandaids layered on top of what to me feels like a shaky foundation. I've obser…

Does an underlying theory exist that meets the requirements of being analysed, understood, and refactored? If so, how does it look? Remember that it should meet the requirements of zero-cost abstractions and concurrency with thread safety, etc. No GC, VM, or interpreter language please.

Rust beginner notes & questions

There's a lot to address in your post but I'd like to know how many days (or whatever unit of time is appropriate) in are you with Rust?

Rust beginner notes & questions

I looked at it very briefly a year ago, just a couple of days of experimentation in the Rust Playground. At the time, I was excited by its use of traits and the heavy reliance on templates, because I was interested in implementing a practical non-commutative geometric algebra for a relativistic rendering engine. Most languages fall flat on their face when presented with abstract mathematics, but at the time Rust had most of the machinery necessary for such a project. More than Julia! More than M…

Rust beginner notes & questions

This is available in an external crate: http://rust-num.github.io/num/num/index.html Futures are generic and not tied to IO. There’s, eg, a way to spawn arbitrary functions (closures) onto a threadpool that’s not at all tied to IO. Not sure what you mean here. slice - Rust. There’s also slice - Rust. I don’t think so. You can define multiple modules in the same file or use subdirectories. Completely agree and your feedback is welcomed. My point, however, is that Rust is a complex …

[DrizztVD1]

The relevant parts of the first linked post are mentioned below. Expand the linked posts above to read further. Be sure to keep on-topic, remarks on the author's style is relegated to a theoretical and general discussion here.

@peter_bertok

I’ve observed that successful languages take some core mathematically sound theory and produce a concrete, applied implementation of it. Relational theory became SQL, typed lamba calculus became functional programming, object oriented theory is wildly popular, etc…

I feel like Rust came >this< close to implementing something similarly ‘pure’, for a want of a better word, fell short, and is slowly sinking into the same messy quagmire that makes C++ so repulsive to me now after having used it for over a decade and then abandoned it for vastly more productive languages.

I think part of this is that most of the Rust core development team comes from a C++ background, and to them, Rust is a huge improvement relative to what they’re used to. This is true, but it feels like a step backwards for everyone else used to elegant languages with a more consistent underlying logic.

The most telling aspect is the general disregard for IDE integration in Rust. It’s been, what, 8 years and there still isn’t a first-class integration with any development environment out there! Tab-complete is woeful at best, and refactoring is basically hopeless.

So… lets all assume that deep IDE integration really is a goal. How is this going to happen? Having poked through the source of the standard library, I’ve noted that huge chunks of it is implemented with macros. The language is a littered with automagic landmines, and from what I’m seeing this is just getting worse. The IDEA team, known for their fantastic tooling across a range of languages, is struggling to make Rust work after over a year of effort. For example, the line use nom::* breaks their IDE, making it forget what str is. I don’t even…

So what’s the fix? I feel like automatic deref is already one step too far in the wrong direction. Compile-time-lifetimes are brilliant, but the fact that NLL took this long indicates that there is no sound underlying theory that can be analysed, understood by humans, or refactored by IDEs.

I’m going to keep poking away at some toy Rust problems as a learning exercise, but I just can’t see any utility in it at the moment. There’s too many ‘undefined behaviors’ for it to feel safe, not enough SIMD to make it truly performant, and it’s not productive enough to replace C# or its ilk at the moment…

[bgeron]

@DrizztVD1

So… lets all assume that deep IDE integration really is a goal.

I think it's a goal on the long term. We're making great progress on that with rls, and I'm content with that for now. I think we shouldn't rush deeper integration if it comes at a cost of slowing down progress in the language/compiler too much.

@DrizztVD1

The IDEA team, known for their fantastic tooling across a range of languages, is struggling to make Rust work after over a year of effort. For example, the line use nom::* breaks their IDE, making it forget what str is. I don’t even…

Isn't that the fault of IDEA's Rust plugin then? This seems to work well in rls.

@DrizztVD1

I feel like automatic deref is already one step too far in the wrong direction.

I feel automatic deref is a core part of Rust's ergonomics, and we must not sacrifice it so that it's more convenient to write IDE integrations. Again, rls seems to deal with this just fine.

@DrizztVD1

the fact that NLL took this long indicates that there is no sound underlying theory that can be analysed, understood by humans, or refactored by IDEs

Now you're just speculating from thin air. There are clear designs in the RFCs.

@DrizztVD1

There’s too many ‘undefined behaviors’ [in Rust] for it to feel safe

Perhaps rather than undefined behavior you mean that Rust has a steep learning curve? It does have that, at least for the time being.

@DrizztVD1

Does an underlying theory exist that meets the requirements of being analysed, understood, and refactored?

On a core level, sure, there's lambda calculus with linear/affine types and regions. Tofte et al's papers on region-based memory management investigate some aspects of that. But even if that language were exactly defined, it doesn't have a syntax in the sense of programming languages, and we really do need a surface syntax. The essence of Rust could be one.

@DrizztVD1

IntelliJ tab-complete failing when faced with files larger than a kilobyte or so

That's really annoying! It's sad that both IDEA and IntelliJ are so bad with Rust. I wonder if the editor situation is turning away a lot of people from Rust. If it does, perhaps on the website we should list some editors that work great with Rust and some editors that are very buggy with Rust, so that at least this papercut is reduced when people try it out.