Corrode is a Rust consultancy blog with practical posts on compile times, async Rust, learning curves and language pitfalls.
Commenters link its compile-time tips as a thorough guide, while one criticizes its Go-to-Rust migration guide as misinformation and a mixed bag.
It's a mixed bag of a blog post. Reading it, and your response, I see all of this as growing pains. The Rust async split mentioned in the post is a legitimate issue. It's also a consequence of immaturity. Rust async underspecified async runtimes and, naturally, incompatible async runtimes emerged and leak all over. The shrapnel of that plagues crates.io. A thoughtful post about this is found here[1]. On the other hand io_uring, new and immature as it is, suffers from security problems, to the point it's been turned off on important platforms, like containerd (by default,) Android, ChromeOS and elsewhere.
As for the actual need for Rust async: there is a real point here as well. While many applications have no actual need for the benefits of Rust async for the bulk of their code, nearly all of them are using it pervasively because that's what the dependencies they're using have been built on. Why? The best answer I can offer is "webscale anxiety": if your thing can't at least theoretically claim to handle Cloudflare levels of IO concurrency out of the box it's garbage, apparently, and no one will consider it. An ecosystem wide case of premature optimization. The cost of that is all the great things that might be done in Rust, but aren't, either because the attempt failed after the developers gave up trying to cope with Rust async, or they've already been through that one or more times and forego Rust by default.
The good news is these problems are all solvable…
The article seems to be just a way to say "Rust is better" - and it fails to do so by spreading misinformation such as the channels part (https://corrode.dev/learn/migration-guides/go-to-rust/#channels) or making a fair comparison of pprof vs Rust's flamegraph.
It also skips entirely over debugging (delve vs gdb), IDE support, ecosystem (why the hell does Rust have N async runtimes?!), statically linking and so on.
A comparison between the performance of RLS / rust-analyzer (painfully slow) and gopls would be enough to kill the whole argument about developer happiness and productivity.
It even passes traits as a "reason to switch" to Rust - where in fact it would probably be a reason (IMHO) not to use it (together with lifetimes).
I think both languages are amazing, so a migration Go -> Rust (or Rust -> Go) makes no sense most of the time.
I've written code in both for a while now, so I know the pain and advantages of both.
For example, Go sucks at microcontroller stuff - in fact it's not even Go officially (see my presentation about porting "Go" to an ESP32-S3 [1]) - whereas Rust is amazing and even has a strong project behind (https://esp.rs) and amazing tooling (probe-rs & co).
What's also not addressed here is the Go ecosystem. The Go packages are one `go mod add` away (pkgs.go.dev) and the module owner guarantees v1 backwards compatibility for the whole lifetime of the module. This means that, no matter what happens, your dependencies will always be up-to-date…
Language hype always justifies itself through intellectualizing its own desire.
In this incarnation we don't always hear, "Rust is the future."[1] We hear:
* "improving security, ensuring long-term maintainability, and optimizing performance" "memory safety, concurrency, and performance" [2]
* "its ability to prevent common programming errors such as null pointer dereferences and buffer overflows" [3]
* "is that it's very portable." [4]
* "I believe that we should shift the focus away from memory safety (which many other languages also offer) and instead focus on the explicitness, expressiveness, and ecosystem of Rust that is highly competitive" [5]
* "Better error messages.Providing comprehensive internationalization support (UTF-8). Improved performances" [6]
All of these things are operational and thus quantifiable, and some (perhaps even most), are probably true. But none of them engage with evidence-based decision making. Therefore it's not really about any of these, but that's what we've been doing since the beginning of time.
1. Although we do hear this[5].
2. https://uutils.github.io/blog/2025-02-extending/
3. https://bytegoblin.io/blog/the-power-of-rust-on-linux-a-beginners-guide.mdx
4. https://lwn.net/Articles/1007907/
5. https://corrode.dev/blog/foundational-software/
6. https://github.com/uutils/coreutils
Hmm. There are "plenty" of Rust jobs outside of crypto stuff. They are:
- Your typical service driven stuff (aka full-stack/backend/microservice et. al)
- Tons and tons of opensource projects from AWS (investing), Microsoft (investing) and Google (yes, investing) to name a few off the top of my head.
- Startups have so to speak started embracing Rust https://corrode.dev/podcast/
- Embedded Systems <- C/C++/ASM's bread and butter traditionally.
- Rust ecosystem is maturing faster than anything I have seen in the past (ok, maybe Go's ecosystem was fast as well).
Regarding AI and ML stuffs: While I do agree that chasing such hype may be intangible in the very short to short time frame. No doubt, the AI winter may follow a typical curve and follow up with a AI "summer". _Every_ major technology in the past 20-30 years has followed a V curve. AI/ML probably won't be an exception.
I understand that the OP may have hobbies outside of "learning" but making a dedicated time outside of it will yield by leaps and bounds. Always be learning (make time for it) - that's the gist in short without going into the nitty gritties.
> Build times
> I'm surprised I didn't see any advice about skipping proc macros or Serde for faster compile times.
A more comprehensive document on build times is at https://corrode.dev/blog/tips-for-faster-rust-compile-times/
We're integrating parts of it into Cargo's official documentation at https://doc.rust-lang.org/nightly/cargo/guide/build-performance.html
We're coordinating the work on that at https://github.com/rust-lang/cargo/issues/16119
> > If you use dev builds but don’t often use a debugger, consider disabling debuginfo. This can improve dev build times significantly, by as much as 20-40%.
We're wondering if we should split iterative development from debugging to pull in these improvements (and maybe more). This is being explored at https://github.com/rust-lang/cargo/issues/15931
How many of those advanced concept in Rust such as borrow checker & lifetime could be avoided as a beginner? If utmost performance is not required (i.e., for mortals dealing with Java/Python/JS on a daily basis) would those lifetime and borrow checker concepts be a hinder to move quick?
I read this article https://corrode.dev/blog/prototyping/ and it seems to address almost all of my concerns when I started learning Rust. I think it could take a beginner a long way until they need to get down to the borrow checker/lifetime. I said I agree with the blog "mostly" because there are situations where you have to interact with 3rd party libraries or APIs dealing with those lifetime. The, you need to know about those concept. If you know a better way to handle this, please let me know.