4 ms·
So many times I've seen a more readable, simpler code turned out to be more efficient as well. In other words, if it's easy for the CPU to read, it's probably
by userbinator 4y ago
So many times I've seen a more readable, simpler code turned out to be more efficient as well.
In other words, if it's easy for the CPU to read, it's probably going to be easy for a human too. They both stumble a little on indirection and jumping around.
The other advantage of simple (macro-level, and not "one line functions" micro-level simplicity) code is that it also tends to have fewer bugs, and what bugs do appear, are also easier to find and fix.
- jenadine 4y agoI disagree. Many abstraction makes it easier to read for human. Example, the first abstraction is to use functions, if/else, and loops instead of plain goto everywhere like the CPU like. Now abstraction also have a cost that needs to be kept under control. (Some have zero costs, some have compile-time costs, some have different level of run-time costs) And of course, not every abstraction is a good one: Sometimes it can even be counter productive to hide details if these details are simpler than the abstraction itself. In summary, it's all about trade-offs and not over-doing it.
- dsego 4y ago> Many abstraction makes it easier to read for human. Many abstractions are also conventions, just look at the js/react world. There is redux stores, mobx stores, hooks, class-based components, signals. All different abstractions with various performance and readability concerns. Someone used to one of them would say the others are not readable or maintainable. So maybe we can choose the more performant abstractions and teach them, so it becomes institutional knowledge.
- badpun 4y ago> Example, the first abstraction is to use functions, if/else, and loops instead of plain goto everywhere like the CPU like. CPU likes if/else and loops just as much as it like its gotos. If/else and loops are just conditional jump (with a comparison done before the jump), and gotos are uncoditional jumps. Both are very much machine code constructs, that's why they're in C (which is basically a syntactic sugar over assembly). Function calls are slightly more involved, but basically also very, very low level.
- jenadine 4y agoyou don't write if (!condition) goto else_; // some code goto endif; else_: // the else block endif: // More code Same for loop. That's what we mean by "goto considered harmful".
- kaba0 4y agoSo why don’t we write plain old assembly then, ad absurdum? Here are my thoughts in a bit more detail from a previous thread: https://news.ycombinator.com/item?id=35061151 https://news.ycombinator.com/item?id=35061151
- fulafel 4y agoA problem with that is that compiler technology hasn't really progressed to do big whole-program or data-layout optimizations from high level specs. If we were closer to the model where a program would read its fixed inputs (for the run) and it would be specialized in place for the input using partial evaluation, with profile feedback for data accesses to help transforming the internal data representations to optimize storage requirement and cache access patterns, we would be much more motivated to specify many things abstractly enough to give machine representations of the code and data more freedoms.
- haspok 4y agoThe whole C64 scene are shaking their head in disbelief. The CPU couldn't care less about "easy readability" (whatever that even means) of your code. Ever heard of self-writing / self-modifying code? Probably an extreme example, and it can be used both ways - for performance reasons (unroll those loops!) or for abstraction (macros are your friend!).
- bigbillheck 4y agoOne thing you have to remember about modern CPUs is that they are not fast 6502s.