Because of this we optimize for different trade-offs in our codebase. Some projects need it, and you see them dropping down to handwritten SIMD assembly for example.
But for the most of us the major concern is making changes, updates, and new features. Being able to come back and make changes again later for those ever changing requirements.
A bridge engineer is never going to build abstractions and redundencies on a bridge "just in case gravity changes in the future". They "drop down to assembly" for this and make assumptions that _would_ cause major problems later if things do change (they wont).
I guess my point is: optimizing code can mean multiple things. Some people want to carve out of marble - it lasts longer, but is harder to work with. Some people want to carve out of clay - its easier to change, but its not as durable.
It's more or less the same as code migrations we're doing on a regular basis, done far more diligently.
When stuck between longevity v less durable, maintainability should be the deciding factor.
Software doesn't have these set-in-stone never-changing requirements. I think we are making similar points.
I have a feeling this guide is written for high performance, while it's true that premature optimization is the devil, I think following this sort of advice can prevent you from suffering a death from a thousand cuts.
That's fine, but it's often a good idea to separate "do some work on a thing" and "maybe do work if we have a thing". Using the example in the article, it is sometimes useful to have multiple functions for those cases:
fn frobnicate(walrus: Walrus) {
...
}
fn maybe_frobnicate(walrus: Option<Walrus>) {
walrus.map(frobnicate)
}
But also… in languages like Rust, most of the time that second one isn't needed because of things like Option::map.But it's an interesting discussion nonetheless. What I picked up, even if it wasn't directly mentioned (or I might have missed it?), is that a simple check on the caller side can be nice for the reader. Almost zero cost reading at the call site because the branch is a short one, and chances are the check provides some context that helps to understand what the call is all about:
if(x is Walrus) frobnicate(x);
is not just control flow, it doubles as a friendly reminder that frobnication is that thing you do with Walrusses. So my takeaway is the check stays in the function (I also don't agree with the article), but make it a part of the naming consideration. Perhaps "frobnicateIfWalrus" wouldn't be so bad at all! I already do that occasionally, but perhaps it could happen more often?
Because easy counterexamples to both of these rules are:
1) I'd much rather have a function check a condition in a single place, than 20 places in code check the same condition before calling it -- the whole point of functions is to encapsulate repeated code
2) I'd often much rather leave the loop to the calling code rather than put it inside a function, because I'll want to loop over the items only to a certain point, or show a progress bar, or start from the middle, or whatever
Both of these "rules of thumb" seem to be motivated to increase performance by removing the overhead associated with calling a function. But one of the top "rules of thumb" in coding is not to prematurely optimize.
If you need to squeeze every bit of speed out of your code, then these might be good techniques to apply where needed. But there are not at all rules of thumb in general.