Almost five years ago, Saoirse “boats” wrote “Notes on a smaller Rust”, and a year after that, revisited the idea.
The basic idea is a language that is highly inspired by Rust but doesn’t have the strict constraint of being a “systems” language in the vein of C and C++; in particular, it can have a nontrivial (or “thick”) runtime and doesn’t need to limit itself to “zero-cost” abstractions.
What languages are being designed that fit this description? I’ve seen a few scripting languages written in Rust on GitHub, but none of them have been very active. I also recently learned about Hylo, which does have some ideas that I think are promising, but it seems too syntactically alien to really be a “smaller Rust.”
Edit to add: I think Graydon Hoare’s post about language design choices he would have preferred for Rust also sheds some light on the kind of things a hypothetical “Rust-like but not Rust” language could do differently: https://graydon2.dreamwidth.org/307291.html
Extremely hard disagree on the last statement. It certainly has tradeoffs, but they are almost all very valuable to many general applications which don’t need performance at all. I’ve been using it professionally for a very long time now and migrated multiple companies from JS, Python, Java, and C# to Rust and it brought huge advantages.
I believe you, but for it to be a fair comparison you’d need to compare to an alternative rewrite, not to the original software.
Rust has plenty of merits. It has a very readable functional style, single aliasing to reduce complexity, powerful libraries for stuff like generating serialisation code, and cargo is incredible.
However, expressing any complex graph structure in Rust is just painful, and so is refactoring code. Small changes in intent require complex reworking of data structures, because Rust forces you to be extremely specific about data layouts at all times. These issues crop up constantly in any complex project, and they really slow things down.
Although Rust is a nice language, you can now write functional code with immutable data structures in pretty much any modern, statically-typed language. C#, Kotlin, Scala, Swift, etc. It will be concise, quick to write, easy to modify and pretty fast at runtime.
Perhaps I’m mistaken in some way, but this has been my honest experience after many years using Rust.
That hasn’t been my experience at all, and it’s been for both large refactors as well as complete rewrites.
Rust does care about some things like not having self referential structs or recursive types, but those are super easy to fix. Rust pushes you to not write code in the same way as other languages, and IMO that’s a very good thing. It’s not at all about systems stuff or memory layouts.
Rust’s ownership system is used to simply enforce correct usage of APIs. Memory safety is simply a subset of correctness. Many other languages, Java for example, don’t enforce thread safety, so you have to be really careful when parallelizing your code. In Rust, you could hire an intern fresh out of high school and I can know 100% that they’re not making mistakes with sending data across threads that isn’t thread safe.
Another example is file handles. Rust is the only mainstream language where it’s not possible to read from a file handle after it’s been closed. That has nothing to do with memory layout or systems concerns. That’s a basic invariant across all languages, and Rust stops you from making a mistake. Same with things like mutating an iterator during iteration and all kinds of other stuff.
That does mean it is more painful upfront, but that’s a good thing. You’ll run into many of the same problems in other languages, but at runtime, which is much worse.
As for graphs, I doubt the vast majority of programmers need to build custom graph structures.
You’re of course free to disagree. Just weighing in with my perspective.
I appreciate your perspective, thanks for taking the time to share it!
I also agree with most of your points in favour of Rust. It is clearly the biggest programming language design breakthrough in decades.