@ramsey @pollita sounds like $a++ is slower than ++$a because assembly used to have a different number of operations for both (or something like this)

Or COUNT(1) is faster than COUNT(*) because that last one first expands into the list of fields (disregarding the query optimizer)

Or beware the 6 fingers, that’s how you tell it’s ai generated

A lot of the early knowledge we took pains to gather, turns out to be noise

@GuillaumeRossolini @ramsey *Technically* $a++ is still slower than ++$a, because the former has to create a tempvar to save rhe value prior to the increment, what the latter can iincrement and just forward fhe new value.

Technically, because *every* compiler for *every* language quietly transforms $a++ into ++$a when it can see the result is not used.

@pollita @GuillaumeRossolini @ramsey Except C++, I guess 😜

https://godbolt.org/z/o48rcvGzz

#include <iostream>

struct Foo {
void operator++() {
std::cout << "pre\n";
}

void operator++(int) {
std::cout << "post\n";
}
};

int
main(void) {
Foo f;

f++;
}

@timwolla @GuillaumeRossolini @ramsey That's a contrived (and flawed) counter-example. The compiler can see that the operators are overridden, so it knows not to elide the side-effects. Same as it would if the result were consumed:

# int a; ++a;
add DWORD PTR [rbp-4], 1
# int b; b++;
add DWORD PTR [rbp-8], 1