I am not hating on Rust. I am honestly looking for reasons why I should learn and use Rust. Currently, I am a Go developer. I haven’t touched any other language for years, except JavaScript for occasional front end work and other languages for OSS contributions.
After working with almost every mainstream language over the years and flitting between them on a whim, I have fallen in love with Go. It feels like ‘home’ to me - it’s comfortable and I enjoy working with it and I have little motivation to use anything else. I rage every time I get stuck working with JavaScript because dependency management is pure hell when dealing with the intersection of packages and browsers - by contrast, dependency management is a breeze with Go modules. I’ll grant that it can suck when using private packages, but I everything I work on is open.
Rust is intriguing. Controlling the lifecycle of variables in detail appeals to me. I don’t mind garbage collectors but Rust’s approach seems far more elegant. The main issue for me is the syntax, specifically generic types, traits, and lifetimes. It looks just about as bad as C++'s template system, minus the latter’s awful compiler errors. After working almost exclusively with Go for years, reading it seems unnecessarily demanding. And IMO the only thing more important than readability is whether it works.
Why should I learn and use rust?
P.S.: I don’t care about political stuff like “Because Google sucks”. I see no evidence that Google is controlling the project. And I’m not interested in “Because Go sucks” opinions - it should be obvious that I disagree.
You should learn Rust because you think that the language is intriguing and that controlling the lifespan of a variable is an interesting feature.
I’ve used Rust professionally for five years now, and it is too hard to give a full answer in any single comment. There are so many reasons. You are right, it is a lot more elegant. You can do things with its type system which you can’t in any other mainstream language, because of ownership. It’s really a life changing experience, so I’d suggest you just try it out, build a project in it, and see what it’s like. You won’t regret it.
I strongly disagree about generics / syntax. IMO they’re fine and you’ll learn to love them.
The high level answer I’ll give is that Rust is a language that is designed from the ground up to not make many sacrifices. You can use it for systems programming where you can’t use a garbage collector, or for high level stuff like an API server. It feels high level while also being as low level as you need it to. Its errors are absolutely fantastic. Same with the tooling and package manager.
You should really just see for yourself.
The main issue for me is the syntax, specifically generic types, traits, and lifetimes.
After working almost exclusively with Go for years, reading it seems unnecessarily demanding.
Like someone else said, this is a complex subject to answer. The syntax looks perplexing and frustrating, until it doesn’t. These days, Rust syntax is nowhere in my thought while coding - it like when you drive, you are thinking about where you want to go rather than about manipulating the controls.
Why should I learn and use rust?
Rust’'s rules are about enforcing memory safety. But it also ends up forcing you to write better programs than what you imagined you could. It’s hard to describe that feeling - you have to experience it. That alone is a good reason to learn it - even if you end up not using it in the future.
Rust’s unique design also leads to many design patterns not normally seen in most other languages. That’s also worth exploring.
I have fallen in love with Go. It feels like ‘home’ to me
That’s a perfectly good thing. It’s hard to find that sweet spot. However, don’t let that stop you from exploring the alternatives. You might find ideas you could use in Go.
Rust’s unique design also leads to many design patterns not normally seen in most other languages.
I’ve heard quite a few people talk about how good they realised Options were, and that they now try to use that same pattern in other languages like Python. It really does teach you new tricks!
I don’t know how useful Options are in Python, with its duck typing. Python had something similar to Option::None
all along - None
. It’s possible to use None in Python is very idiomatic and surprising ways. Rust’s Some
and None
are tagged unions. And Rust forces you to address them - unlike Python.
Well, with the newer optional typing, it became def foo(name: Optional[str]) -> Optional[str]: ...
and now def foo(name: str | None) -> str | None: ...
(No need to import Optional) It’s quite nice.
As for Rust, recall that Result is also a very similar union type. I think a lot of the aversions people have had to static typing have mostly just been about poor expressiveness in clunky type systems.
Go is a great language. I used it a few times when dealing with bugs in open source programs. And though I never used it besides that, I could spot and fix these easy issues fast.
Rust is not like that. The syntax is a little harder to read and a lot of widely used libraries use complex macros to ease their users lives.
But:
I cannot count the times rust has saved my ass.
Examples:
Sqlx checks my sql files against a local test-db and always errors, when my scripts miss parameters after changing the sql file.
I have to use a complicated mess of an API at work to get the data I need and I now use a 50-60 element enum that tells me exactly, what I got back from the API-calls.
When I write code, it’s typically in Go or Python.
The reason I’m curious to learn Rust is specifically to contribute to existing projects that are written in Rust.
If you’re interested in working on Lemmy code, for example, you’ve gotta learn some Rust to do it.