Why Every Rust Crate Feels Like a Research Paper on Abstraction
Posted3 months agoActive2 months ago
daymare.netTechstory
calmmixed
Debate
70/100
Rust Programming LanguageAbstraction in Software DevelopmentLibrary Design
Key topics
Rust Programming Language
Abstraction in Software Development
Library Design
The article discusses how Rust crates often feel overly complex and abstract, sparking a debate among commenters about the trade-offs between abstraction and simplicity in software development.
Snapshot generated from the HN discussion
Discussion Activity
Very active discussionFirst comment
33m
Peak period
24
12-24h
Avg / period
8.3
Comment distribution50 data points
Loading chart...
Based on 50 loaded comments
Key moments
- 01Story posted
Oct 19, 2025 at 5:11 AM EDT
3 months ago
Step 01 - 02First comment
Oct 19, 2025 at 5:44 AM EDT
33m after posting
Step 02 - 03Peak activity
24 comments in 12-24h
Hottest window of the conversation
Step 03 - 04Latest activity
Oct 24, 2025 at 6:19 PM EDT
2 months ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
ID: 45632943Type: storyLast synced: 11/20/2025, 4:38:28 PM
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
Coming from a Java world with heavy use of annotations and their behind the scenes magic I fear the Rust world that overuses macros.
Don't get me wrong. I understand that the way annotations work in Java is quite different from macros in Rust and you don't need to convince me that Rust macros are a ton better and cleaner and more useful while in a sense being even more lightweight.
I still dread a world with Rust becoming like Java where complicated and impenetrable magic is considered a virtue and not a sin. The main enabler to this is in my opinion is the overuse of macros, as wonderful and magical as might be.
I share this fear. Rust macros are _amazing_ and indispensable but their overuse makes understanding third party code extremely difficult. There are cases where macros are used to avoid repetition, I feel like code generation makes more sense here, where crates publish expanded syntax.
My other fear is the fragmentation of standard interfaces. AsyncRead and AsyncWrite are prime examples. If you build an http server you end up using tokio's AsyncRead AND futures AsyncRead - then a bunch of glue code to make them compatible with each other.
I'd love to see the standard library reinforced with crates that are basically default installs for their use cases. Tokio, futures, http, httpparse, maybe a variant of anyhow.
Using hyper with streamed http responses (which depends on tokio::duplex). You're already depending on the futures and async-compat crates to adapt tokio futures. I don't even know how hyper could be set up to use another async backend or what performance penalty another adapter layer would have on performance.
> Much of futures' functionality is now in the standard library (core::future)
In that case, I would love to see Tokio move to depend on the stdlib interfaces rather than exporting their own lookalikes. That way runtimes can be interchangeable. I guess the same goes for utils like task::sleep, channels and fs interactions.
However you will miss the STS tooling.
But it was nice to learn a little bit more about why I wouldn't like Rust.
>The real tragedy? Once you see it, you start writing that way too. You start thinking, "Well, maybe I should make this generic in case someone wants to use quaternions instead of matrices..." and suddenly, congratulations – you're building for someone who doesn't exist.
is awful similar to LLM writting. I can't put my finger on exactly where, but that the impression i got.
I suppose "coauthored" is a more charitable word though. This article wasn't as bad as most slop. I imagine the author passed it through Grammarly or something.
Most seemed to believe it was approximately 2/3 AI generated text. Primarily the first several paragraphs. Last, and second to last scored the best as "human". ZeroGPT said it was only 5% likely AI written. Couple sentences.
CopyLeaks, 61.9%. https://app.copyleaks.com/dashboard/v1
GPTZero, 80%, 64/80 sentences. https://gptzero.me/
ZeroGPT, 5%. https://www.zerogpt.com/
Not sure if that means its actually AI written, cause there's lots of argument about false positives. Also, it's software. In many ways it seems like a lot of that field / genre produces articles and writers that then have a very "structured" writing style. Read a lot of HN. Write articles that place on HN. Tailor your writing style so it gets upvotes on HN.
It's very similar to the Youtube issues, and people making their intro, thumbnail, and splash screen before even considering article content much. Mr. Beast had a leaked article on the subject. Lots of SEO, Click-Thru-Rate, Average-View-Duration, ect... [1]
[1] https://www.businessinsider.com/mrbeast-how-production-team-...
Programming language choice is a matter of taste to a large degree so it's possible the different people value different traits of languages.
"When in doubt leave it out", is a design decision that can be taken to extremes in some cases and many of us feel crippled and don't enjoy such languages. There can be languages that provide powerful abstractions and rely on its users' trust to use them appropriately. Of coyrde, like every tool it can be misused but that should not be the baseline we use for comparison. Because surely we can find dreadful code in every language.
As a closing paragraph I'll just say that Scala 3 is very nicely designed language that simplifies a lot of the sticky point with Scala 2 and allows for a nice blend of OOP and functional programming. Functional programming in Scala is opt-in and progressive and is a good choice for greenfield projects on the JVM. Also a final note, tooling for Scala and Scala 3 specifically has improved a lot to the point where it just works without arcane invitations of the past. Overly confident opinions to the contrary for people who haven't touched the language since 2018, scala 2.11 and sbt 0.13 are quite out of touch.
Metals and InteliJ still have issues with Scala 3, and Eclipse plugin is stuck in Scala 2.
> the ones who’d use Zig if it weren’t allergic to syntactic sugar
You’re very close to understanding why some people prefer Zig. There is a correlation between language design and how things are built with it.
Precisely, same for Go. Incentives decide outcomes.
1: https://wmaxey.github.io/cccl/thrust/api/function_group__tra...
Presumably the author is one of them. Or they simply use a text editing or blogging software that takes care of it.
E.g. Markdown with smarty-pants feature turned on generates them automatically from '--'. 'Em' dashes require '---'.
Coincidentally Rust's `cargo doc` does this for you -- just for example.
The conclusion that a text containing such micro-typographic niceties must be LLM-generated is a fallacy thusly.
Your other 'evidence' sounds like an interpretation to me. Maybe you should quote the sections you mean?
Otherwise your critique seems superficially limited to form, not contents -- an ad-hominem in disguise one may be tempted to conclude.
In many other languages ideas are separated by en-dashes (surrounded by spaces).
In the case at hand the use of en-dashes in English text instead of the correct em-dashes could also be a sign of a non-native speaker caring about micro-typography and just doing the wrong thing. :)
The LLM conclusion doesn't seem well supported either way.
classic llmism
For generics, no, but you can query this information in your IDE pretty easily. You can also also use `cargo doc` to build the generated documentation, which will show you the list of traits something implements.
It seems like outside certain problem domains, there isn't any effort to pool resources to keep projects alive. The few I did find were forks of forks where each subsequent maintainer stopped responding to proposed changes.
(I presented on it recently: https://www.chrisarmstrong.dev/posts/icfp-wrapup-2025-10-18)
This isn't unique to Rust. I find exactly the same thing about C++. I will often have to wade through 8 layers of constructors to find where some field is set.
However, I wonder if the "Orphan Rule" makes it worse in Rust. It is not uncommon for you have to create a trivial "newtype" to wrap something because of the orphan rule. A couple of layers of that and you've got an impenetrable mess on your hands.
The C obstrufication contest makes an artform out of it. I think that's apt, and honest. Many open source projects are a form of art. People create to art say something about themselves. What better way so say how inventive you are, than to find a novel way to use the programming language?
I'm guilty of it myself. But once I got it out of my system and look back, I have to agree with the author. While these novel constructions are fun to create, that are pain in the arse for others to learn and even worse to maintain.
I don't think that Rust encourages it any more than any other language. The author should try looking at the sins Lisp's macro's and Python's meta classes enabled. Well, except for Rust's macro's. I suspect creative use of Rust's macro's would make the C obfuscation contest look like kindergarten artwork.
TLDR this is the real reason
Anyway I don't use Rust and I just learned that writing generic code is more complicated. It's interesting because in Julia generic code is the simple path: just don't add types and it's generic. Multiple dispatch is a powerful idea and I wish more languages adopted it.
i write rust sometimes, python and go mostly. i never even think about "the community" when i use python and go. but so much online stuff seeps into the rust user experience, through libraries and tooling.
> Want to do something slightly off-script? That’ll be three trait bounds, one custom derive, and a spiritual journey through src/internal/utils/mod.rs
An alternative is: you want something off-script, go fork the repo with the crate and patch it to accept your use case.
Hey, that's a neat idea.
What if we could make a whole useful system that one single person can understand completely down to the bottom (in a single lifetime or less)?
Doesn't mean you have to understand it, but a system that you could if you wanted to. If possible, also, something familiar (in contrast to an esoteric TempleOS like thing).