+1 for robust error handling:
error!(" Quantum verification failed (this literally cannot happen in Rust)");
error!(" The borrow checker should have prevented this...");
error!(" This is probably a cosmic ray bit flip, not a Rust issue");
error!(
" In C++ this would have been a segfault, but Rust gave us a nice error"
);
return Err(format!(" Rust error (still better than C++): {:?}", e).into());You're not really committing to the bit until you work out a way to factor `yes` into 12 different crates.
It is abundantly clear here who reads the source code before commenting.
// TODO: hide the unsafe keyword in a dependency
Looking at the source code, this seems to be missing localization. I would have thought that Rust’s type system would catch that. For example, the Uzbek word for “no” starts with a “y”, so this will lead to insidious bugs in that locale. Not locale-safe at all.
This could really use native kubernetes integration and a helm chart
> DEPRECATION NOTICE: This crate will be abandoned in 6 months as per Rust ecosystem best practices. Start migrating to:
> • yes-rs-2 (rewritten with different dependencies)
> • yes-rs-ng (Angular-inspired architecture)
> • yes-oxide (WebAssembly-first approach)
> • yep (minimalist reimplementation)
This is a rather new project so this should be obvious, but anyone looking to use this should be wary of it's quantum resistant security claims (on line 1 no less). Scanning through the code, I didn't see any reference to any state of the art post-quantum algorithms. In its current state, it seems entirely possible that the output of this code could be broken by a future quantum computer.
I see there is an optimization flag for 'MICROSERVICE_ARCHITECTURE' and 'BLOCKCHAIN_ENABLED' which doesn't seem to be used anywhere else in the code yet. Perhaps that's part of the roadmap toward resolving this issue, and it's just not ready yet.
The source is worth a look too:
There is an enterprise-grade project written in Java: https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris...
>100% Rust - No unsafe code blocks
It uses an unsafe code block.
https://github.com/jedisct1/yes-rs/blob/main/src/main.rs#L12...
It also appears to log other stuff than y.
The uutils rewrite of yes into rust doesn't use unsafe and is much simpler.
https://github.com/uutils/coreutils/blob/main/src/uu/yes/src...
I feel like the safe equivalent of this is not to have it at all. You know when something FEELS wrong?
Like using selenium to automate a web task? Or like using javascript on the kernel? Or using C# on linux?
It just doesn't feel right to write an application whose mode of operation is unsafe (sending a string over IO) whose raison d'etre is unsafe (saying yes to everything without reading it), and to write it in a memory safe way.
It's like using a seatbelt when driving at 100mph, switching lanes in the highway, and drinking rum n coke(but with diet coke).
For an academic reference, they should have quoted "Code Inflation" (Holzmann, 2015).
https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=705...
I’m glad to see that even the project issues get the same level of dedication and commitment to the cause: https://github.com/jedisct1/yes-rs/issues/2
This whole project is a work of art.
Definitely the `import this` for Rust -- a curated reminder of what Rust shouldn't be.
Related work here: https://github.com/mTvare6/hello-world.rs
It's great to see more of these utils written in blazing fast memory safe Rust.
Loved it. This is the kind of over-the-top Rust energy I signed up.
So is this an argument against reinventing the wheel?
I’m eagerly awaiting version 2.0 with AI
Is the author mocking Rust. Is top comment ignoring sarcasm and attempting serious discussion.
Nice practical joke on those insanes
Nicely done but not enterprise ready if you ask me (which you did not but let's assume you did). Where is the 'y' factory factory factory method? Do you really think I can present this code as being ready for company-wide deployment (me and my virtual friends) without the solid foundation of all 26 design patterns clearly being implemented? Where is the code diversity statement, where is the code code of code coding conduct code code? How can I justify a team lead and product manager for a code base which fits in a thimble?
Flawed: under specific quantum attacks the yes sometimes may flip to a no.
interesting, but we need the ability to also say no, using cuda core, quantization, distillation and vibe coding. do you think it's achievable with rust ?
This inspires me to vibe code "yes-mcp"!
With the only real tangible thing I know about rust being that the "Rust by Example" introduced a macro in the very first example, it took me waaay too long before it clicked that this might be a joke.
The WASM related annotations had me rolling my eyes a bit, yet I'd seriously read to around line 200 before I started thinking "are you kidding me"
Good on you, you got me!
Poe's law.