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.
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.
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.
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.
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::Noneall along -None. Itās possible to use None in Python is very idiomatic and surprising ways. RustāsSomeandNoneare 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 nowdef 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.
I have been programming in Python for nearly two decades now. This is the first Iām hearing about the
Optionalimprovements to Pythonās type hints/annotations. Thanks a lot for this. Iām going to take a re-look into type hints.Iām aware that Rust enums, including Result, are tagged unions. However, my understanding is that itās not like that in Python. Pythonās duck typing is enabled by typing the values, rather than the variables. A variable can point to a value of any type. Am I getting this wrong? Or is
Optionaldifferent somehow?