Lines of Code
yes (GNU) 50
Yes-rs 1,302 (26x more)
Lines of Code
yes (GNU) 50
Yes-rs 1,302 (26x more)
[0] https://github.com/uutils/coreutils/blob/main/src/uu/yes/src...
int main(int argc, char *argv[])
{
if (pledge("stdio", NULL) == -1)
err(1, "pledge");
if (argc > 1)
for (;;)
puts(argv[1]);
else
for (;;)
puts("y");
}
[1] https://github.com/coreutils/coreutils/blob/master/src/yes.c
[2] https://github.com/openbsd/src/blob/master/usr.bin/yes/yes.c
[3] https://www.reddit.com/r/unix/comments/6gxduc/how_is_gnu_yes...
The GNU-yes
$ yes | pv > /dev/null
... [10.2GiB/s] ...
void main() {
while(write(1, "y\n", 2)); // 1 is stdout
}
$ gcc yes.c -o yes
$ ./yes | pv > /dev/null
... [6.21 MiB/s] ... yes | pv > /dev/null
0:00:15 [1.12GiB/s]
build/yes | pv > /dev/null
0:00:20 [1.03GiB/s]
package main
import "core:sys/linux"
import "core:os"
import "core:strings"
main :: proc() {
msg := "y" if len(os.args) == 1 else os.args[1]
msg = strings.concatenate({msg, "\n"})
buf := transmute([]u8) strings.repeat(msg, 8192)
for {
linux.write(linux.STDOUT_FILENO, buf)
}
}I suspect what you suggest creates a more voluminous dump but is slower in the desired use case
yes &
The GNU version of true/false is more interesting. All the logic is in true and false just redefined the EXIT_STATUS and imports all of true.c. https://github.com/coreutils/coreutils/blob/master/src/false...
It unnecessarily duplicates the for loop. I would have written something like:
char *what = argc > 1 ? argv[1] : "y";
for (;;)
puts(what);In 99% of cases, yes of course you’re right, factor this loop.
In this specific case? This is trivial code, that will likely _never_ change. If it does change, it’s extremely unlikely that the two loops would accidentally diverge (the dev would likely not miss one branch, tests would catch it, reviewers would catch it). So if you get any upside by keeping the two loops, it might be worth it.
Here you get 8 bytes back. I honestly can’t see how that would ever matter, but hey it’s _something_, and of course this is a very old program that was running on memory-constrained machines.
So it’s a trade-off of (minor) readability versus (minor) runtime optimisation. I think it’s the better choice (although it’s very minor).
Or maybe there’s a better reason they chose this pattern… can’t imagine the compiler would generate worse code, but maybe it did back in the days?
If you consistently deduplicate code that is supposed to do the same and evolve the same, then any duplicated code sticks out as a statement of “this isn’t the same”, and in the present case it then makes you wonder what is supposed to be different about both cases. In other words, such code casts doubt on one’s own understanding, raising the question whether one might be overlooking an important conceptual reason for why the code is being kept duplicated. So in that sense I disagree that the duplicated version is more readable, because it immediately raises unanswered questions.
About possible performance reasons, those need an explanatory comment, exactly for the above reason. And also, if performance reasons warrant complicating the code, then it isn’t “as simple as it gets” any more. I was commenting because I disagreed with that latter characterization.
for (;;) {
if (argc > 1)
puts(argv[1]);
else
puts("y");
}
You said "it’s about duplicating logic that should inherently be the same", but that is exactly how it is more explicit, by having this duplication. I assume your problem is with the two "puts()"?
But still, I don’t see why you wouldn’t first name what you want to output before starting the outputting. If anything, I’d place the whole output loop in a separate function and have two calls to that function. Nevertheless, it’s even better to express in code the fact that the program doesn’t want to make a distinction between a literal “y” and an argument “y”, by consolidating them into the same variable.
Another way to do this would be to have a static default argument array containing the “y”, and for example having:
if (argc <= 1) { argv = default_argv; }
for (;;) { puts(argv[1]); }
Though I think the separate variable (what) is clearly preferable.
> in that sense I disagree that the duplicated version is more readable
I didn't say it is, I agreed it's _less_ readable. I said it's trading off readability for 8 bytes of memory at runtime.
> If you consistently deduplicate code that is supposed to do the same and evolve the same, then [...]
I agree with all this. I'm not saying to consistently go for the deduplicated approach (I don't think anyone would say that), I'm saying it's a reasonable trade-off in this specific case (each branch is still trivial, and the code won't evolve much if at all).
> About possible performance reasons, those need an explanatory comment, exactly for the above reason.
Agreed.
> if performance reasons warrant complicating the code, then it isn’t “as simple as it gets” any more. I was commenting because I disagreed with that latter characterization.
Also agreed.
This joke project has a lot of truths in it that others do dead seriously; something to think about.
// Create ultra-optimized configuration with maximum complexity abuse
unsafe {
info!(" Creating quantum string with unsafe (but it's okay, it's Rust unsafe)");
info!(" This unsafe block is actually safe because I read the Rust book");
info!(" Unsafe in Rust is nothing like unsafe in C++ (much better!)");
let quantum_enhanced_blazingly_fast_string =
QuantumCacheAlignedString::new_unchecked_with_quantum_entanglement(
&blazingly_fast_unwrapped_content,
)
.map_err(|e| format!("Quantum string creation failed: {:?}", e))?;
// Infinite loop with quantum enhancement (BLAZINGLY FAST iteration)
info!(" Starting BLAZINGLY FAST infinite loop (faster than C, obviously)");
info!(" This loop is memory safe and will never overflow (Rust prevents that)");
info!(" Performance metrics will show this is clearly superior to GNU yes");
Gregory Bateson's "A Theory of Play and Fantasy" (in Steps to an Ecology of Mind) (1972): Bateson argues that certain communicative acts signal themselves as "play" or "non-literal." A joke is such an act—structured and marked by "metacommunicative" cues, indicating that it should not be taken at face value.
Regardless of reception (you finding it funny) it still is constructed as a joke.
Sorry for being pedantic :^)
Further reading: https://www.reddit.com/r/AskHistorians/comments/tbgetc/comme...
Satire doesn't have to be funny; it just needs to make commentary through irony.
https://web.media.mit.edu/~minsky/papers/jokes.cognitive.txt
>Abstract: Freud's theory of jokes explains how they overcome the mental "censors" that make it hard for us to think "forbidden" thoughts. But his theory did not work so well for humorous nonsense as for other comical subjects. In this essay I argue that the different forms of humor can be seen as much more similar, once we recognize the importance of knowledge about knowledge and, particularly, aspects of thinking concerned with recognizing and suppressing bugs -- ineffective or destructive thought processes. When seen in this light, much humor that at first seems pointless, or mysterious, becomes more understandable.
>A gentleman entered a pastry-cook's shop and ordered a cake; but he soon brought it back and asked for a glass of liqueur instead. He drank it and began to leave without having paid. The proprietor detained him. "You've not paid for the liqueur." "But I gave you the cake in exchange for it." "You didn't pay for that either." "But I hadn't eaten it". --- from Freud (1905).
>"Yields truth when appended to its own quotation" yields truth when appended to its own quotation. --W. V. Quine
>A man at the dinner table dipped his hands in the mayonnaise and then ran them through his hair. When his neighbor looked astonished, the man apologized: "I'm so sorry. I thought it was spinach."
>[Note 11] Spinach. A reader mentioned that she heard this joke about brocolli, not mayonnaise. This is funnier, because it transfers a plausible mistake into an implausible context. In Freud's version the mistake is already too silly: one could mistake spinach for broccoli, but not for mayonnaise. I suspect that Freud transposed the wrong absurdity when he determined to tell it himself later on. Indeed, he (p.139) seems particularly annoyed at this joke -- and well he might be if, indeed, he himself damaged it by spoiling the elegance of the frame-shift. I would not mention this were it not for the established tradition of advancing psychiatry by analyzing Freud's own writings.
>ACKNOWLEDGMENTS: I thank Howard Cannon, Danny Hillis, William Kornfeld, David Levitt, Gloria Rudisch, and Richard Stallman for suggestions. Gosrdon Oro provided the dog-joke.
And jokes can be a construct without being humor as well.
Don't try take the fun out of life.
Well, not technically, but I know someone who is.
In fact LLMs are perfect for this..!
#![allow(unused_imports)] // We need ALL the imports for quantum entanglement
#![allow(dead_code)] // No code is dead in the quantum realm
#![allow(unused_variables)] // Variables exist in superposition until measured
#![allow(unused_mut)] // Mutability is a state of mind
#![allow(unused_macros)] // Our macros exist in quantum superposition until observed
#![allow(clippy::needless_lifetimes)] // Our lifetimes are NEVER needless - they're crab-grade
#![allow(clippy::needless_range_loop)] // Our loops are quantum-enhanced, not needless
#![allow(clippy::too_many_arguments)] // More arguments = more crab features
#![allow(clippy::large_enum_variant)] // Our errors are crab-sized
#![allow(clippy::module_inception)] // We inception all the way down
#![allow(clippy::cognitive_complexity)] // Complexity is our business model
#![allow(clippy::type_complexity)] // Type complexity demonstrates Rust mastery
#![allow(clippy::similar_names)] // Similar names create quantum entanglement
#![allow(clippy::many_single_char_names)] // Single char names are blazingly fast
#![allow(clippy::redundant_field_names)] // Redundancy is crab safety
#![allow(clippy::match_bool)] // We match bools with quantum precision
#![allow(clippy::single_match)] // Every match is special in our codebase
#![allow(clippy::option_map_unit_fn)] // Unit functions are zero-cost abstractions
#![allow(clippy::redundant_closure)] // Our closures capture quantum state
#![allow(clippy::clone_on_copy)] // Cloning is fearless concurrency
#![allow(clippy::let_and_return)] // Let and return is crab methodology
#![allow(clippy::useless_conversion)] // No conversion is useless in quantum computing
#![allow(clippy::identity_op)] // Identity operations preserve quantum coherence
#![allow(clippy::unusual_byte_groupings)] // Our byte groupings are quantum-optimized
#![allow(clippy::cast_possible_truncation)] // Truncation is crab-controlled
#![allow(clippy::cast_sign_loss)] // Sign loss is acceptable in quantum realm
#![allow(clippy::cast_precision_loss)] // Precision loss is crab-approved
#![allow(clippy::missing_safety_doc)] // Safety is obvious in quantum operations
#![allow(clippy::not_unsafe_ptr_arg_deref)] // Our pointers are quantum-safe
#![allow(clippy::ptr_arg)] // Pointer arguments are crab-optimized
#![allow(clippy::redundant_pattern_matching)] // Our pattern matching is quantum-precisehttps://gitlab.com/mcturra2000/cerbo/-/blob/master/x64-asm/0...
Some people seem to revel in assembly, but I now know why C exists.
yes | pv > /dev/null
and was getting about 5.4GiB/s
On the fasm code, I was getting a meagre 7.3MiB/s. Ouch! The non-assembly version is considerably faster. I wonder if it is because I make a syscall for every write I want to perform, whereas C uses buffering, or something.