I didn't love that article - Rust isn't strictly a systems language. It's general purpose, and a lot of the mechanics are very useful for general programs.
this post was submitted on 11 Jan 2024
34 points (87.0% liked)
Rust
5938 readers
1 users here now
Welcome to the Rust community! This is a place to discuss about the Rust programming language.
Wormhole
Credits
- The icon is a modified version of the official rust logo (changing the colors to a gradient and black background)
founded 1 year ago
MODERATORS
I feel like you may have missed the point, then? Or at least interpreted the article very differently? Rust isn't "strictly" a systems language, but neither is C or C++; people use them for application development all the time. But all three languages have very specific limitations (most obviously, that adding a garbage collector would be an unwelcome change) imposed by the need to fulfill the "systems" niche.
Compare Golang: it can't replace C++ for every use-case, because it has a garbage collector, and because you need cgo to use FFI. But it's otherwise a very flexible language that can be used for most types of software.
What I would like to see is something that shares these advantages with Go:
- quick to build
- easier to teach & learn than Rust
- easier to quickly prototype with than Rust (though of course it's debatable how well Go does at this one)
...but I don't like the actual language design of Go, and I think it's possible to design a language that's more Rusty but still simpler than actual Rust.
For instance, error handling in Rust is both more ergonomic and more rigorous than in Go. That's huge! A language like Go but with sum types, Result, and the question-mark operator would be leaps and bounds nicer than Go itself.
To be clear, I don't imagine that a "smaller Rust" would replace Rust. But I also don't think we've reached optimal language design when the language I'd pick to write an OS is also the language I'd pick to write a small CLI app.
load more comments
(2 replies)
Rust is a groundbreaking language, but it's not without tradeoffs. There are loads of things it makes extremely difficult compared to slightly higher level languages.
I used it happily for years, but I wouldn't recommend it for any project that didn't explicitly need the low-level performance optimisation.
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.
Why would you want that? What is wrong with python if you want an interpreted language with garbage collection? By contrast what is wrong with rust + a lot of crates (or C++/Ada/...) if you want a compiled language?
Zero cost abstractions are great because speed is very important for complex problems. Little things here and there make for modern computers that feel slower than my old 8 bit atari when trying to get work done.
There is a huge and valuable possibility space between python and Rust. We know this because it is already occupied by many extremely successful languages (Java, C#, Swift, etc).
The value of a language that sits between C# and Rust also seems pretty obvious at this point; a language that gives you Rust's memory management tools for optimisation, but doesn't force you to use them for all of your code.
load more comments
(3 replies)
Copying what I wrote in another comment:
What I would like to see is something that shares these advantages with Go:
- quick to build
- easier to teach & learn than Rust
- easier to quickly prototype with than Rust (though of course it's debatable how well Go does at this one)
...but I don't like the actual language design of Go, and I think it's possible to design a language that's more Rusty but still simpler than actual Rust.
For instance, error handling in Rust is both more ergonomic and more rigorous than in Go. That's huge! A language like Go but with sum types, Result, and the question-mark operator would be leaps and bounds nicer than Go itself.
To be clear, I don't imagine that a "smaller Rust" would replace Rust. But I also don't think we've reached optimal language design when the language I'd pick to write an OS is also the language I'd pick to write a small CLI app.
Learning a programming language is not hard. there are thousands of choices. Before you ask for another one, first please check that there isn't already one that meets your needs. Fragmentation of languages is not useful in general. It is rare to have an idea that hasn't been tried before, so find someone who already has done that idea.
... I am currently asking if there is a language that fits the description. And I'm clearly not the only one interested in such a language.
I personally have not found Rust onerous to learn, especially by comparison to C++. But a lot of people do find the learning curve steep.
Coming from some one who used 4 different languages (C#, C++, Python, and G'MIC), I just feel more comfortable when there's a explicit end blocks, which is why I don't like Python. Of all of those languages, only Python does not make that explicit end block which is off-putting in my opinion, and there isn't any other options with the similar role to Python.
Ruby often comes up as a python alternative. There are a lot of other lesser known choices - but any of them will still be more popular (at least at first) than something you come up with and thus any of the will give more community support.
You mean a interpretative language with similar role to Python, but more like Rust/C++ style? I actually want that so that I can ditch Python even if I learned it and use this instead.
Not necessarily interpreted, but possibly. I think a more likely path is something like Go that's compiled but still has a garbage collector.
If you use a garbage collector the whole borrow checker would not make any sense.
Do you want to have error handling and functional paradigms in go? I think you should start there and ask go Devs why their language is lacking such basic stuff.
I spend an inordinate amount of time at my C# day job adding documentation comments about exclusive access and lifetimes and ownership… things which are clearly important but which dotnet provides little or no useful support for, even though it has a perfectly good garbage collector. The dotnet devs were well aware that garbage collection has its limits, especially when interacting with resources managed outside of the runtime, and so they added language features like IDisposable and finalisers and GCHandle and SafeHandle and so on to fix some of the things GC won’t be doing for you.
I’d happily use a garbage collected language with borrow checking.
load more comments
(1 replies)
Not sure if this is what OP is seeking, but I would be fine to have borrow checker removed, replaced with Garbage collector like Go/Python in such a language.
To build prototypes, I don't want to fight with borrow checker and neither I care for efficiency much. But I do want the macro system, traits, lazily asynchronous runtime, cargo like package manager, easy build system, etc.
Rust has so many powerful features, but only because of borrow checker (IMO) we can't use it for rapid prototyping like Python. With that replaced, this subset of Rust would be something which can be a great contender to Python/Go, etc.
The borrow checker handles more than just freeing allocated memory, it will also prevent data races and invalid concurrent access aso. I personally don't have any issues with using garbage collected languages, but the fearless concurrency is nothing I'm willing to give up.
Oh, I agree.
My worst experiences with Python are related to running multiple processes of which share anything. Rust was far easier in that.
Looks like interpreted Rust would be my only demand for Rust to shine in prototyping world.
Honestly, prototyping is exactly the kind of thing where I don't want to think about all the crap that Python doesn't check itself while Rust does. In a long-term project I could begrudgingly learn every data structure and process well enough to do the compiler's job for it but if the code is very new or changes constantly I want as much support from the compiler as possible to avoid having to remember all of that.
To build prototypes, I don't want to fight with borrow checker and neither I care for efficiency much. But I want [rust features]
Maybe we just need a preprocessor that adds clone, reference counting and RefCell wherever needed.
load more comments
(4 replies)
Did you read the original "Notes" post? I thought it did a pretty good job of explaining why Rust-like ownership semantics are not necessarily at odds with having a garbage collector.
F#? It's compiled, statically typed, somewhat fast, garbage-collected, and supports Rust-style error handling
Definitely a good pick! I haven't learned it but I'm aware of some of its features, and it does seem promising.
I think inko is close to matching this description.
The biggest difference I see is allowing multiple mutable borrows, which would make a lot of things easier, but aside from that it sounds like it would have most of the same usability problems as Rust.
I'm also a bit put off when I see LLVM advertised as the primary compiler back-end these days. Pretty much guarantees slow builds.
I'll check it out; thanks!
I think I saw something called 'Rune' that might fit the criteria pretty well. I didn't dig really deep.
I'm not joking. If you want something that's very similar to Rust, but doesn't have the restriction of being a systems language, then Haskell might be the right thing for you. Unlike Rust, Haskell is Pure Functional though, so it forces you to have an even cleaner architecture.
If Pure Functional isn't your beer, then you could also check out the language that inspired Rust: ML. If I remember correctly, Rust was started as "something similar to ML, but suitable for systems programming". So, it only feels natural to take an ML dialect if you want "something similar to Rust, but without the restriction of it being suitable for systems programming".
A popular ML dialect would for instance be F#, which is built on top of the .Net runtime and is therefore compatible with C# and the likes. On the other hand, in order to make it compatible with C# and the likes, there are some weird compromises in F#...
Or, if you (like me) dislike the idea of having a Garbage Collector, you could go for Lean4. That's what I'm learning currently, and it feels a bit like a bastard child of Haskell and ML.
Im surprised you didn't mention OCaml or Elm
OCaml seems really close, but I'm told that there are problems with its concurrency story. I do think it sounds like a really good language.
I'm curious if you were told that recently. I know that there have been stable releases of major features and libraries concerning concurrency and parallelism near the end of 2022. It may be much improved since you your source last looked. Or it could be a limitation in the implementations of these.
My understanding was that there's some ecosystem bifurcation, somewhat like Rust's. But I'll look into it again!
Oh, yeah. The Jane Street vs non-Jane Street library incompatibilities still exist. But there is a new concurrency library that was made such that the need to use monads has been eliminated.
I did mention ML, of which OCaml is a dialect. Afaik Elm doesn't have type classes (aka Traits) - a property I would consider necessary to call it "similar to Rust".
load more comments
(1 replies)
have an even cleaner architecture
Although I'm fully in camp functional, I doubt that. There are problems that are inherently stateful and rely on mutability. Modelling that in Haskell often results in unnecessary abstractions. I think Rust hits a sweet spot here (when you're that experienced to write idiomatic Rust, whatever that exactly is). Also being lazy by default has its own (performance) implications, strict + lazy iterators (like Rust) is a good default IMO.
I do want to learn Haskell some day, but it seems like it has a whole different set of reasons why it's tricky to learn; and I hear enough about the more complex features (e.g. arrow notation) having compiler bugs that I think it really doesn't sound like a "smaller" or "simpler" language than Rust.
That said, yeah, it definitely meets the criteria of having strong typing, a functional style, a garbage collector, and pretty good performance.
view more: next ›