It happened again. Another week, another holy war on the timeline. And, of course, it's the Rust crowd leading the charge...
Apparently, the new gospel is that thanks to Rust, you can grab any library you want from crates.io, glue it in, and hallelujah it “just works.”
No need to read the code you just added to your project.
Yeah. It “works” right up until the moment you actually try to maintain it, debug it, or god forbid, ship it to production.
Your shiny continuous integration pipeline is green, your tests pass, and it gets deployed to production... Because of course you automatically deploy if the Rust compiler said it built...
Then production logs start screaming and your so-called “safe” codebase detonates because your dependency maintainer decided to refactor their core API on a Friday night.
When “It Just Works” Means “You Just Got Lucky”
Rust fans love to brag that the compiler saves them from (their) stupidity.
And it does, to a degree it stops them from doing memory management like drunk programmers.
But here's the thing: safety guarantees don't extend to logic, design, or sanity.
That “trusted” library you just pulled into your project might have enough unsafe buried inside it to make a kernel developer sweat.
Rust's memory safety doesn't protect you from sloppy abstractions, race conditions at the app level, or the “oh, this update just hijacked your API keys” special.
The Rust compiler doesn't spot that, genius.
Dependency-Driven "Engineering"
Here's where new software “engineers” lose me completely.
They've replaced understanding with cargo add, pip install, and npm install.
They're not solving problems... they're injecting someone else's half-assed solution from six years ago into your project.
And the best part? They treat it like engineering. Like popping dependencies from crates.io or npm is somehow professional.
Writing use_library_for_modulus_evenness instead of x % 2 == 0 doesn't make you efficient, it makes you helpless.
Sure, Rust makes it harder to get segfaults... but that doesn't mean you should turn off your brain.
Own your damn stack. Write your own utilities once in a while.
Stop duct-taping other people's design decisions to your project and pretending it's “modern architecture.”
Think Before You Pull
Use libraries. Of course. No one's expecting you to hand-roll your own compiler or network stack (though you'd learn a lot if you tried).
Library are great, I use them all the time, but only when they are a good fit for the problem I'm trying to solve.
But stop installing libraries like candy from a jar.
Every dependency you add is one more unknown in your threat model, one more black box you didn't read, one more thing that'll explode during a demo.
The moment you trust other people's code more than your own judgment, you've already lost control of your software.
At this point you don't deserve to call yourself an engineer, you're a dependency hoarder, a lego builder.
And the worst part is, you'll convince yourself that's progress. And rust won't magically change that fact.
