This blog post is laden with emotions, feelings, and opinions, read Rust For Foundational Software | corrode Rust Consulting if you want a more neutral and objective take, and not the kat experience.
ASSUMED AUDIENCEAnyone who wants to know why I like Rust so much (duh).
Developers curious about why people like Rust so much.
Anyone who’s interested about the social aspects of programming language adoption.
Why Rust
Let’s get the obvious points out first.
People advertise Rust because (so far) it’s the only language that’s memory safe, doesn’t have a garbage collector, and has performance comparable to C (or as No Boilerplate put it, “Fast, Reliable, Productive, pick THREE”).
You don’t need to worry about memory safety, and performance is great. People are noticing the advantages, and the industry adoption for Rust is increasing.
While that’s a good hook to get people into starting Rust, those aren’t the reason people stick with Rust.
Performance isn’t the only factor that matters for industry adoption (see: all the applications written in Python, and Electron+JS).
Memory safety doesn’t matter that much either (see: Zig, a more ergonomic C with practically the same foot guns as far as I can see to C. Or god forbid Go with all the concurrency hazards, which is praised for easy to use concurrent features, AND it decided to bring back null pointers).
IMHO, what ended up making a difference is more social than pragmatic. Rust has great tooling, the community is inclusive. It takes the best parts of functional programming, and brings it to the masses.
And, for me, coming from Python, the biggest factor was predictability.
Rust also has better defaults, good practices in other languages are enforced in Rust.
Another thing is the dreaded borrow checker, which deserves its own section.
Predictability
So, what do I mean when I say predictability?
The first thing which comes to my mind for explaining is that Rust doesn’t have exceptions or implicitly nullable objects.
Rust has Result<T, E> which signals to the human that “This function can fail
in ways that you might be able to recover from”. Result isn’t anything
special, it’s just a widespread convention. From what I gathered, in C, the
convention is to take pointers as arguments for where to store the data, and the
function itself returns a 0 to signal success, and some other integer as error
code.
There are multiple ways to say “null” which signals a different kind of “null”.
The most common being Option<T> that signals “This function might, or might
not produce a value” where the Option::None is treated as null. Others include
() (empty tuple) signalling no return value (like void return type in C),
! (never returns) signalling the function doesn’t return anything, not even
void.
Rust makes you explicitly deal with Result, and Option. You can’t ignore
them. You can say you don’t care about it, or you know it won’t happen by doing
.unwrap(), but that’s you making a choice. In Go, and C, you can ignore the
result. In JS, and Python, you don’t even know if the function can error. Zig
saw the benefit and requires you to declare the function can error, but adding
context for why it failed as a payload requires works.
Just knowing if the function can fail, or not return anything reduces cognitive load. I know when a function is going to fail, and I can react to it.
Borrow checker
I’ve always wondered, the compiler has access to my code, it should know when I’m done with a variable and automatically free it. Most variables are temporary and limited to the scope anyway. Why can’t the compiler “just” see that?
When I first heard about how Rust cleans up memory automatically, I was like “fucking finally”. Then I heard about how it forces you to either have, multiple readers, or a single writer. If you think about it, it’s the same thing databases enforce internally, so it clicked almost instantaneously for me. I went, “Oh, that’s just like a database, that’s cool”. So I never got why people kept complaining about the borrow checker.
Like, you guys can make complex software that I can only dream of making, but the borrow checker is confusing??? Also, aren’t you supposed to follow the readers xor writer rule anyways??? If the compiler makes sure you follow the rule, isn’t that just a good thing?
Sure, it makes it harder to architect large software compared to when you implicitly follow certain rules, but I feel like if the borrow checker is making it difficult then I’m doing something wrong.
How does it tie back to predictability?
Borrow checker makes it so you know if a function is going to delete a value,
modify a variable, or if it just needs to read it. It also removes the confusion
of “does this function modify the value or does it return a new value”.
Send and Sync
Next thing, Rust has Send, and Sync markers. Send signals that the object
can safely be sent to another thread. Sync signals that the object can safely
be shared with another thread. I think Send is pretty easy to understand, it’s
just moving an object from one thread to another. Sync on the other hand felt
confusing to me, what does it mean for an object to be shared? “Shared” here
means that even if you send a pointer to the object to another thread, when the
other thread dereferences the pointer, the pointer is still valid, and the data
is in “sync” with what the original thread sees.
In the above diagram, the envelope represents packing up the data, and sending
it to another thread. Which means the ownership is being transferred from
Thread-2 to Thread-1. On the other hand, while Thread-2 owns meow,
Thread-1 can still read it, so, Thread-2 has the ownership of meow, but
Thread-1 has read-only access to it.
Enough yapping, let’s see an example.
Producer–Consumer problem
In this case, the data we send, well, needs to be marked Send. The queue on
the other hand needs to be marked Send, and Sync. At any time, the data is
owned by one thread only, but the queue needs to be accessed from both, the
consumer, and the producer. The producer will send the data to the queue, and
the consumer will consume the data from the queue. So, it is important that both
see the same data.
Here’s one way to write the producer-consumer program
fn main() {
let queue/*: Vec<&str> */ = Vec::new();
let queue/*: RwLock<Vec<&str>> */ = std::sync::RwLock::new(queue);
let queue/*: Arc<RwLock<Vec<&str>>> */ = std::sync::Arc::new(queue);
let producer/*: JoinHandle<_> */ = {
let queue/*: Arc<RwLock<Vec<&str>>> */ = queue.clone();
std::thread::spawn(move || {
loop {
std::thread::sleep(std::time::Duration::from_millis(193));
let Ok(()) = queue.write().map(|mut x| x.push("meow")) else {
println!("Poison detected in producer");
return;
};
}
})
};
let consumer/*: JoinHandle<_> */ = {
let queue/*: Arc<RwLock<Vec<&str>>> */ = queue.clone();
std::thread::spawn(move || {
loop {
std::thread::sleep(std::time::Duration::from_millis(211));
let Ok(mut queue) = queue.write() else {
println!("Poison detected in consumer");
return;
};
if queue.is_empty() {
println!("Queue empty");
continue;
}
let data = unsafe {
// Safety: We checked if the queue is empty above.
queue.pop().unwrap_unchecked()
};
// Do something with it
_ = data;
}
})
};
let handles/*: [JoinHandle<_>; 2] */ = [producer, consumer];
let Ok(mut prev/*: usize */) = queue.read().map(|x| x.len()) else {
println!("Poison detected before loop!");
return;
};
while handles.iter().any(|x| !x.is_finished()) {
let Ok(curr/*: usize */) = queue.read().map(|x| x.len()) else {
println!("Poison detected while in loop!");
return;
};
if prev != curr {
println!("{}{curr}", if prev > curr { '📉' } else { '📈' });
prev = curr;
}
}
}See it run on rust playground: Link to playground
As you see in the above diagram, queue is on the heap, and it has 3 owners:
- The
queueinmainthread. - The
queueinproducerthread. - The
queueinconsumerthread.
But, at any point, either one thread is modifying the queue, or it’s being read
from multiple threads, which is being enforced by the RwLock. So, here, the
queue needs to be Send + Sync.
The easiest way to make sure there’s no data race while accessing data from
other threads is to make it immutable. Wrapping the data in Arc does that.
But, in our case, we also need to modify the data. To do so, Rust has an escape
hatch with “interior mutability”. Mutex is one example of that. However,
Mutex only allows for one reader or one writer. RwLock allows you to have
either a single writer, or multiple concurrent readers. In our case, the
performance difference won’t be that apparent. However, it should be fine.
But how does the compiler know that the queue is Send and Sync? I didn’t
explicitly mark anything as Send or Sync. The rust compiler automatically
marks structs as Send if everything inside the struct is Send. Similarly,
if everything inside the struct is Sync, the struct is also Sync. So, unless
you’re implementing your own synchronization primitives, you won’t need to
explicitly mark stuff as Send and Sync.
In this case, Vec<T> is Sync if T is Sync, and Vec<T> is Send if T
is Send. Our payload is "meow", which is of type &'static str', which
stored in the data section of our binary, so it is Send, and Sync. Next,
RwLock<T> is Send if T is Send, and Sync if T is Send + Sync,
which it is. Finally, Arc<T> is Send + Sync if T is Send + Sync, so, our
queue can be safely accessed from multiple threads, and it can be manipulated
safely from multiple threads as well.
But, since Vec<T> is Send + Sync, why did I still wrap it in RwLock and
Arc?
It’s because Vec<T> can only have one owner, if I refer it in another thread,
rustc complains that I need to move the ownership. Once it moves, I cannot
access it in the main thread. If I try to use a reference instead, then rustc
complains that the reference might not live long enough. One solution can be
using std::thread::scope instead since rust will join the handles
automatically once the scoped handles reach end of scope. But, rustc still
complains about the lifetime of the reference. Thus, I need something which
allows for shared ownership. In single threaded scenarios, Rc<T> is used,
however, since I’m using multiple threads, I have to use Arc<T>. But, Arc
makes the data immutable, so I need interior mutability, and thus, I have to
wrap the data in RwLock, and the lock inside Arc.
Tooling
If you release a new language today, you can’t just get away with releasing the
language, and the docs.
You need to have a good LSP.
You need to have a good package manager.
You need to have a good build system.
You need to have a good formatter.
You need to have a good linter.
You need to have a good test framework.
You need to have a good way to view docs.
Rust tooling is so good, people are copying it and creating tooling for other ecosystems, like uv for Python.
Rustup — The mothership
Rustup is the first thing you need to install to use Rust.
Rustup manages Rust versions, and toolchains. Rustup also helps install all the other tools.
Cargo — Build System, Package Manager, Linter
Cargo is the default build system, package manager, linter for Rust.
It’s also the entry point to most of the tools below.
Truly a one-for-all tool.
Rustfmt — Formatter
Rustfmt is a tool used to format Rust code according to the community’s style guidelines
Rustdoc — Documentation Generator
Rustdoc generates documentation and produces HTML that you can read in a browser.
Rust-analyzer — LSP
Rust-analyzer is the default LSP for Rust.
Clippy — More advanced linter
Clippy is an add-on linter that makes your code more idiomatic, and prevents common mistakes.
The lints it has are more advanced compared to the default lints in Cargo.
Miri — Undefined Behavior Sanitizer
Miri checks for undefined behavior in unsafe blocks. So, even unsafe isn’t as unsafe as people make it out to be.
cargo-bench — Benchmarks
Compile and execute benchmarks.
User-created tooling
These are some of the tools developed by the community.
cargo-semver-check — SemVer violational linter
Lint your crate API changes for semver violations.
cargo-tarpaulin — Code Coverage
Tarpaulin is a code coverage reporting tool for the Cargo build system
cargo-insta — Snapshot Testing
Cargo Insta is the companion command line tool to assist with snapshot reviewing.
cargo-flamegraph — Profiler
A Rust-powered flamegraph generator with additional support for Cargo projects! It can be used to profile anything, not just Rust projects! No perl or pipes required <3
cargo-pgo — PGO optimizations
Cargo subcommand that makes it easier to use PGO and BOLT to optimize Rust binaries.
divan — Benchmark
Fast and simple benchmarking for Rust projects
cargo-fuzz — Fuzzer
A cargo subcommand for fuzzing with libFuzzer! Easy to use!
kani — Model Checking
The Kani Rust Verifier is a bit-precise model checker for Rust.
Kani is particularly useful for verifying unsafe code blocks in Rust, where the “unsafe superpowers” are unchecked by the compiler.
creusot — Formal Verifier
Creusot is a deductive verifier for Rust code. It verifies your code is safe from panics, overflows, and assertion failures. By adding annotations you can take it further and verify your code does the correct thing.
Choices made for Rust
Rust doesn’t just have good tooling.
- It also has great error messages for most common mistakes.
- It has the best features from functional programming languages while still
being performant, compiling to native code, and feeling like a C-style
language.
- Hindley-Milner Type System
- Type inference
- Iterators
- Immutable variables
- Expression based
- It strikes a good balance between language features, and additional syntax.
- Operators like
+can be implemented for any type by implementing the appropriate trait. Option, andResultare just enums and not a special language construct.
- Operators like
Community
OK, fine, Rust the language is great.
But the people also need to be good, it won’t matter how good the language is if the environment is toxic.
And I’m happy to say that the community is welcoming and has DEI as one of their core values. It’s hard to spend one day in the Rust ecosystem without running into queer people.
See: https://blog.rust-lang.org/2025/02/13/2024-State-Of-Rust-Survey-results/#community
But, again, why does it matter?
There’s an interesting phenomenon called curb cut effect, it’s an accessibility feature which helps everyone so much, people don’t even notice it’s an accessibility feature.
IMO, the number of queer people in a community is a good sniff test for toxicity.
Diversity, equitability, and inclusivity are hard metrics to meet as it’s not a single individual’s responsibility. DEI needs to be met as a community wide effort. It’s one thing to have a good product, it’s another thing to have a friendly and inclusive community. Likewise, it takes a monumental amount of coordination and energy to make sure people feel safe.
It’s only political if you think different people are… well… not people.
I focus particularly on queer people as there’s a huge correlation between being queer and being neurodivergent, and neurodivergence is a disability.
You might’ve noticed I keep using the phrase “cognitive load”, why is that?
Rust strikes a good balance between showing information, being explicit, and
requiring you to have implicit knowledge. That makes it attractive to people who
suffer from cognitive impairment. Rust makes it so you can write it safely while
having very little working memory in your brain.
For people who suffer from cognitive impairment, it enables them to write code;
for others, it enables them to be more efficient.
Repeat with me.
Accessibility.
Helps.
All.
Sensible Defaults
Rust also has sensible (and better) defaults, which means most common and best practices have low barrier.
But why does that matter?
Usually, the easy way is the better way.
Take immutable by default for example. In other languages, immutability is an add-on state. Which signals that it’s idiomatic to have mutable variables, and that mutability is better.
You don’t need to constantly remind yourself to do the better thing, the compiler reminds you.
Rust rewired my brain, when I need to write JS/TS, I get anxious. It feels like walking in a minefield. I know something is going to blow-up, I just don’t know where. The computer has access to where the mines are, but it won’t tell me where. It’s not something I should remember, that’s not a feasible ask.
While it’s possible to learn where the mines are in the standard library, it’s not possible to learn it for every library.
We stand on the shoulders of giants,
and we should take advantage of that. Let’s use the advancements people have
made in programming.
Let the computer do what it’s best at, and use the limited time and resources we have to fill in the rest.
While dealing with the borrow checker and Option/Result can be annoying, it made me realize how much better predictability is in the long run. The features that make it more complex in the short term, helps reduce the overall complexity, especially in the long term.
I think corrode put it the best, “Rust is a day-2-language”.
I’m not saying Rust is the perfect language, or Rust has everything I’ve ever wanted from a programming language; but it’s good enough.
Life is all about trade-offs, and I’m saying that Rust’s trade-offs are acceptable for me.
Proofreaders
Divyesh Patil
Typst files
Typst file for the Send/Sync diagram
Typst file for the producer/consumer diagram
Case Studies
While preparing to write this blog post I collected a bunch of other articles and I want to “react” to them / recommend them.
Multiple GCP products are experiencing Service issues (2025-06-12)
https://status.cloud.google.com/incidents/ow5i3PPK96RduMcb1SsW
“Without the appropriate error handling, the null pointer caused the binary to crash.”
lol, lmao ~ 🦂
on type safety
— Adam Chalmers (@adamchalmers.com) June 14, 2025 at 8:12 PM
[image or embed]
Frog put the value in a option. “There,” he said. “Now we will not deref any more null pointers.” “But we can unwrap the option,” said Toad. “That is true,” said Frog.
Yes, but, .unwrap() would’ve raised flags. Also, wrapping the pointer in
Option would be a pretty big signal that “hey, you want to be more careful
here”. In Golang/C++, you don’t even know if the value can be null.
Piccolo - A Stackless Lua Interpreter by kyren (Catherine West)
https://kyju.org/blog/piccolo-a-stackless-lua-interpreter/
Piccolo is a lua interpreter in pure, mostly safe Rust.
Kyren gave up on the VM for four years because she couldn’t figure out how to make it work with the borrow checker.
But, in the end, the architecture she ended up making turned out to have more features like cancellation, and better concurrency.
So, it just made the VM better, and now there’s a reason to use it over other VMs. It’s their “killed feature”.
Borrow checker doesn’t just prevent memory safety bugs, it also forces you to design the program in a better way.
Matt Godbolt sold me on Rust (by showing me C++) by Gustavo Noronha
Gustavo said, and I quote “a well designed language saves you a lot of brain cycles by not forcing you to think about how to protect your code from the simplest mistakes.”
If that’s not reducing the cognitive load then IDK what is.
C++ had decades to learn, but it didn’t matter.
From my personal experience, when I was following Learn OpenGL, I kept shooting myself in the foot because C++ is supposed to have a feature, but MSVC doesn’t support it. I tried to use smart pointers, but I couldn’t use them instead of normal pointers.
Also, it doesn’t mesh with the way I learn. Initially when I have to learn something, I go with spoonfeeding. Once I’m done getting spoonfed, I jump directly into a project, and then proceed to fuck around and find out. I like to see what methods are available on a given struct, and read the docs for them.
I couldn’t do that with C++. I tried to see what other options I can use for
glBegin, and all I saw was macro expansions. Enums being just integers was
also extremely annoying, because I could pass GL_TRIANGLE_STRIP to… let’s
say… glGenerateMipmap.
It felt like the language itself is fragmented.
Ownership Benefits Beyond Memory Safety by Ian Wagner
https://ianwwagner.com/blog/ownership-benefits-beyond-memory-safety
Ian says that it prevents subtle bugs where you don’t know if a function will return a new value or modify the old one.
I feel this the most when I write JS/TS, some functions modify the value, some functions return new value, others modify the value and returns it again, and then some modify and return the old value.
He also mentions that traditional functional languages also have the same benefit, but in their case, everything is cloned because everything is immutable, so you just aren’t given the choice. On the other hand, Rust gives you the choice, and makes the choice explicit.
I’ll directly quote him, “the borrow checker is a powerful ally, and you can leverage it to make truly better APIs, saving hours of debugging in the future.”
Evolution of Rust compiler errors by Kobzol (Jakub Beránek)
https://kobzol.github.io/rust/rustc/2025/05/16/evolution-of-rustc-errors.html
One of the best things about Rust is how good the error messages are.
Here, Jakub shows the evolution of error messages.
To quote the article directly “a lot of effort has to be put into the messages to make them really good.”
It’s interesting to see how the errors went from
info dump which may or may not contain information -> short description but still a lot of information -> just useful information with lots of white space -> colored output to attract your attention to the important detail -> actively telling you what to do.
Communicating in Types • Kris Jenkins • GOTO 2024 by GOTO Conferences
https://www.youtube.com/watch?v=SOz66dcsuT8
Kris discusses how you can use the type system to encode and enforce rules.
Doing so makes communication easier, it allows your code to be the single source of truth.
Why you should use Rust by Sebastian Woehrl
https://blog.sebastianwoehrl.name/blog/2025-05-rust/
Sebastian starts by giving context that he works in with cloud native technologies, and more specifically, Kubernetes. Now, I’d expect someone who uses Kubernetes to use Golang or Python. And he says that he used to use those, but nowadays, his favorite is Rust.
He says Python is good enough for IO-bound applications, but dynamic typing makes things hard.
Golang is good for Kubernetes due to the ecosystem, but existence of nil,
checking errors being optional, silent initialization, and duck-typing for
interfaces are a design issue and make “make working with a large or complex
codebase unnecessarily hard”.
Then he proceeds to talk about why he thinks Rust is great, and why, even though Rust’s ecosystem for cloud-native isn’t that good compared to Golang, he still prefers it. He also goes over the trade-offs.
I do agree with him that the compile times aren’t great, but the trade-offs feel worth it. See:
started working on game #3, spent 1 hour setting up, and then the next 7 hours battling quaternions and bevy, the compilation times are so atrocious JFC
i almost considered starting over in godot
— Kathryn<‘u1f338> (@sakurakat.systems) June 1, 2025 at 10:18 PM
Constructor acquires, destructor releases by Gustavo Noronha
https://medium.com/@gustavokov/constructor-acquires-destructor-releases-e1455b63289c
I think just the quote “I am sure there are data races here, the compiler is just not telling me where” is enough :P
Leveraging Rust Types for Program Synthesis by Jonáš Fiala (ETH Zurich, Switzerland), Shachar Itzhaky (Technion, Israel), Peter Müller (ETH Zurich, Switzerland) Nadia Polikarpova (University of California at San Diego, USA), Ilya Sergey (National University of Singapore, Singapore)
https://dl.acm.org/doi/abs/10.1145/3591278
The paper goes over their tool which generates code from just type signatures.
If Kris Jenkin’s talk intrigued you, you should read this paper.
Codegen your problems away - device-driver toolkit - Dion Dokter by RustNL
https://www.youtube.com/watch?v=xt1vcL5rF1c
I found the “HOLD ON! You can run cargo run AND cargo doc AND cargo fmt
AND rustup update And it just works?” slide hilarious, it also highlights how
good the tools are for Rust, especially when it comes to embedded development.
You don’t need to install anything different for embedded development, and I
think that’s a huge benefit.
We deserve helpful tools - Pietro Albini by RustNL
Pietro talks about the momentous effort that goes into making sure Rust’s error messages improve over time.
It’s Embedded Rust Time - Bart Massey by RustNL
https://www.youtube.com/watch?v=e0T_x7SeNLM
Bart talks about how great the experience is Rust for embedded. It’s similar to Dior’s talk but covers it from a professor’s point of view, and as someone who was working in Rust embedded since before Rust Embedded Working Group was a thing.
Rust Could be a Good Beginner Language by SCP-iota (Hazel)
https://scp-iota.github.io/software/2025/06/11/rust-for-beginners.html
Hazel says that one of the biggest problem with learning Rust coming from another language is that you need to, quote, “Forget Everything You Know”, so it’s easier for beginners to learn Rust, since its just like learning any other language.
Comments on Bluesky
These are just some of the posts I found on Bluesky
ngerakines.me and natalie.sh on why they like Rust
Rust has a lot of pros and cons, and I get that it isn't for everyone. I sure do @smokesignal.events being a single 48.7MB container for both the app and utilities though. #atprotocol #atdev
— Nick Gerakines (@ngerakines.me) May 13, 2025 at 7:52 AM
love to write small and fast programs (mostly) by default
— natalie (@natalie.sh) May 13, 2025 at 9:03 AM
[image or embed]
jamesmunns.com on the ever improving standard library
please do not attempt to fight the collections (you will lose)
— The Museum of English Rural Life (@themerl.bsky.social) May 6, 2025 at 4:57 PM
Rust's approach of continually improving built-in stdlib data structures
— James Munns (@jamesmunns.com) May 6, 2025 at 7:55 PM
[image or embed]
joke explainer/well actually:
Practically, external crates DO beat the std collections pretty regularly, for a while. However whenever practical, the stdlib will adopt the same techniques used to beat it, meaning that picking
— James Munns (@jamesmunns.com) May 6, 2025 at 8:11 PMstd::collectionsis usually a pretty smart choice over a long timescale
i still feel like "better defaults" should be in rust's sales pitch somewhere
— Kathryn<'u1f338> (@sakurakat.systems) May 6, 2025 at 8:33 PM
astrakernel.bsky.social showing bevy running on esp32
B . E . V . Y
Rusting Everything…
#rustlang #esp32 #bevy
— AstraKernel 💫 (@astrakernel.bsky.social) May 7, 2025 at 10:56 PM
[image or embed]
🎮 Breakout Game for ESP32 with OLED Display - Built in Rust Using the Bevy Engine
Thanks to bevy for introducing no_std support
I am not a game dev and this is my first attempt using Bevy(so, I may not have utilised it properly)
github.com/ImplFerris/e…
#rustlang
— AstraKernel 💫 (@astrakernel.bsky.social) May 8, 2025 at 9:29 PM
[image or embed]
gotocon.com showing Kris Jenkin’s talk
https://www.youtube.com/watch?v=SOz66dcsuT8
Modern type systems go beyond the compiler—they're a design language. Watch @krisajenkins.bsky.social explore how types improve thinking, communication, and collaboration in software.
— GOTO Conferences (@gotocon.com) April 25, 2025 at 5:33 PM
[image or embed]
fun, covers all the reasons I prefer strongly typed languages.
another benefit is reducing cognitive load, which Kris hinted at but didn’t explicitly say during the “Describing context” section.
— Kathryn<‘u1f338> (@sakurakat.systems) April 25, 2025 at 7:51 PM
nekotachi.bsky.com and sopwithpuppy.bsky.social talking about how Rust made good language design decisions
i really appreciate rust actually doing interesting things with syntax instead of just "yeah we'll just copy C verbatim ig"
“everything is an expression” is very cool imo.
— soweli Neko (@nekotachi.bsky.social) May 13, 2025 at 11:16 PM
Rust also feels like it has struck the perfect balance between: a bunch of hyperspecific syntax for things, and defining things 'in-language'
like how the ? operator isnt out of place despite optionals being actual enums, or PhantomData being a struct and not an annotation on the generic bound.
— sopwithpuppy.bsky.social (@sopwithpuppy.bsky.social) May 13, 2025 at 11:37 PM
mrjimmyblack.com on how error messages got them through the borrow checker learning curve
I’ve been on rust since 2017 edition. Compiler error messages were what got me through the borrow checker learning curve and they’ve come crazy far since then. kobzol.github.io/rust/rustc/2...
— Jeremy Blackburn (@mrjimmyblack.com) May 17, 2025 at 6:54 AM
[image or embed]
r.bdr.sh talking about Rust’s developer experience
the more i learn rust, the more i want to use it for everything.
i like the errors, i like clippy, i like the language features, but most of all: I like the way it makes you think.
i think “rust is just for systems programming” is more meme than truth.
— mirrorless gamera (@r.bdr.sh) May 17, 2025 at 4:35 AM
eikopf.dev on them being neurodivergent and loving rust
i'm massively neurodivergent and i love programming in rust! it sparks joy! i have committed untold atrocities with macros!
— oliver (@eikopf.dev) May 19, 2025 at 8:01 PM
philpax.me on Rust’s design decisions and piss.beauty being masochist with clippy
languages and linters that make unused variables a fatal error: it's on sight
once again, the glorious Rust programming language has charted the correct path here in making it a warning that you can make fatal if you want
— philpax (@philpax.me) May 20, 2025 at 4:08 PM
you should enable it though
— 🖤stellz🖤 (@piss.beauty) May 21, 2025 at 2:46 AM
keep your sick ways away from me (unless they're on CI on main, in which case I agree)
— philpax (@philpax.me) May 21, 2025 at 2:54 AM
team "every clippy lint is a fatal error"
— 🖤stellz🖤 (@piss.beauty) May 21, 2025 at 2:55 AM
I do something similar! I have a majority of clippy lints on and find them helpful rather than overwhelming or useless.
bencates.bsky.social talking about trans women being overrepresented in Rust community and segfaultvicta.bsky.social theorizing why
bluesky is the place where I help perpetuate stereotypes of trans women being rust programmers and argue with gay men that they have >20% responsibility for Trump, did you look at all that gold leaf, and somehow I am not canceled
maybe because those are actual jokes, though, I dunno
— Ed (@ed3d.net) May 21, 2025 at 7:38 PM
[image or embed]
Jokes aside, trans women really are wildly overrepresented relative to baseline demographics in the rust community and I'd love to know the backstory behind that.
— Ben Cates (@bencates.bsky.social) May 21, 2025 at 7:42 PM
greater-than-background-rate of disaffected trans nerd programmers primed precisely for a language LIKE Rust to exist + early Rust founder effect doing SOMETHING incredibly right to make trans ppl feel comfortable and welcomed in the community, is my sketch of what happened there
— J. C. Cantwell 🌻 (@segfaultvicta.bsky.social) May 21, 2025 at 10:40 PM
I don't know the specific history in detail but I know that must have been what happened, it probably could have been like, Elm or Elixir or something like that but
— J. C. Cantwell 🌻 (@segfaultvicta.bsky.social) May 21, 2025 at 10:40 PM
I have personally experienced how Tim Click makes sure the community is welcoming and comfortable for everyone.
laniakita.com on how useful the Rust compiler is
i still love how friendly the rust compiler is, dropping hints on how to fix buggy code. Ferris 🦀 really is the bestest <3
— Lani (@laniakita.com) June 2, 2025 at 3:14 PM
emily.news replying to steveklabnik.com on how Rust feels more comfortable
#rustlang Could be a Good Beginner Language
scp-iota.github.io/software/202…
— Steve Klabnik (@steveklabnik.com) June 12, 2025 at 3:37 AM
[image or embed]
okay i have been sincerely thinking this since i first started using any Rust. it feels so much more comfortable to engage with a system where the behaviors and boundaries are more explicit, where the tooling is more deeply integrated and more intelligent.
— E = mily² (@emily.news) June 12, 2025 at 4:05 AM
elias.sh quoting corrode.dev’s article
"I believe that we should shift the focus away from memory safety (which these languages also have) and instead focus on the explicitness, expressiveness, and ecosystem of Rust that is highly competitive with these languages" corrode.dev/blog/foundat...
— Elias de oliveira Granja 🦀 (@elias.sh) June 13, 2025 at 10:44 AM
[image or embed]
This post was the reason I read the article and found out just how much better and objective their article is lmao.