> the order of operations might affect the precision of ints/floats

That's only the problem of floats, with ints this issue doesn't exist.

Why do you write (x % 2 == 0 && x % 3 == 0) instead of (x % 2 == 0 & x % 3 == 0), when the latter is what you think you mean?

Are you sure, that dividing by 6 is actually faster, than dividing by 2 and 3? A division operation is quite costly compared to other arithmetic and 2 and 3 are likely to have some special optimization (2 is a bitshift), which isn't necessary the case for 6.

  1 * 2 * 3 * 4 / 8 --> 3
  3 * 4 / 8 * 1 * 2 --> 2

  bool is_divisible_by_15(int x) {
      return x % 3 == 0 && x % 5 == 0;
  }

  bool is_divisible_by_15_optimal(int x) {
      return x % 15 == 0;
  }

  is_divisible_by_15(int):
        imul    eax, edi, -1431655765
        add     eax, 715827882
        cmp     eax, 1431655764
        jbe     .LBB0_2
        xor     eax, eax
        ret
  .LBB0_2:
        imul    eax, edi, -858993459
        add     eax, 429496729
        cmp     eax, 858993459
        setb    al
        ret

  is_divisible_by_15_optimal(int):
        imul    eax, edi, -286331153
        add     eax, 143165576
        cmp     eax, 286331153
        setb    al
        ret

I think it’s really revealing to see so many folks defending views like “hunter gathering was better” and “the past wasn’t dickensian.”

I remember the first time I encountered the former view from a person, they were an artist living in London and a communist. I nearly spat out my beer when he told me that hunter gathering was a better life for humans.

It seems to be some kind of desire to rage against progress, because industrialisation brings many downsides e.g, pollution climate change etc. Maybe because they hate the rich and powerful capitalists that rule the world.

But what they always miss from their arguments is a clear conception of just how incredibly privileged and fortunate they are to be born into an industrialised society. People are very very bad at appreciating what they are given, it seems to be an innate human trait to exhibit breathtaking ingratitude for what already is. We’re pretty good at anticipating and appreciating the new, but if it’s already there then, like a spoilt child living in a luxury home, we take it for granted.

I think one solution to this problem is to remove as many comforts from your life, temporarily. For example, for a week in winter don’t use your heating or hot water. For me, it was travelling to poor countries and living without potable or warm water, decent transport, good food, etc. that made me grateful (at least for a while).

The "problem" is that it's all comparative, even if in absolute terms you are right - life is undeniably better than it used to be by every metric.

But to give you an example - my grandma had 8 siblings, out of which only 4 survived into adulthood. They mostly died before even turning 1, the typical "one day he was fine, the next day he turned purple and died, the nearest doctor was 2 hours away if your neighbour let you borrow a horse cart, so that's just what it was" case. Her father and her uncle were taken into Auschwitz and miraculously returned but never wanted to talk about the horrors they have seen while there. For the rest of her life she endured living under communism, seeing her peers in other countries have access to riches she could only dream of.

So now when you talk to her, how can you blame her for thinking that kids nowadays are spoiled, if they have everything provided for them, they have never experienced physical violence of any kind, but they are all depressed and sad about life being shit and saying how it was better in the good old days.

Like, from her perspective, it's impossible to understand.

But also, from the kids perspectives nowadays, all they know is a world where the "old" people have houses, jobs, stable incomes, and they cannot even hope for any of it. 50 year mortgages, 700 job applications with no interview, social media blasting images of a life that they know they can't ever have.....of course they are depressed. Just showing them stats that say "you live better, comfier, safer andd healthier lives than pretty much anyone else ever in the history of humanity" is not going to help if all they know is how much "worse" they have it than the people who came before them.

Let's throw this into godbolt: https://clang.godbolt.org/z/qW3qx13qT

    is_divisible_by_6(int):
        test    dil, 1
        jne     .LBB0_1
        imul    eax, edi, -1431655765
        add     eax, 715827882
        cmp     eax, 1431655765
        setb    al
        ret
    .LBB0_1:
        xor     eax, eax
        ret

    is_divisible_by_6_optimal(int):
        imul    eax, edi, -1431655765
        add     eax, 715827882
        ror     eax
        cmp     eax, 715827883
        setb    al
        ret

By themselves, the mod 6 and mod 3 operations are almost identical -- in both cases the compiler used the reciprocal trick to transform the modulo into an imul+add+cmp, the only practical difference being that the %6 has one extra bit shift.

But note the branch in the first function! The original code uses the && operator, which is short-circuiting -- so from the compiler's perspective, perhaps the programmer expects that x % 2 will usually be false, and so we can skip the expensive 3 most of the time. The "suboptimal" version is potentially quite a bit faster in the best case, but also potentially quite a bit slower in the worst case (since that branch could be mispredicted). There's not really a way for the compiler to know which version is "better" without more context, so deferring to "what the programmer wrote" makes sense.

That being said, I don't know that this is really a case of "the compiler knows best" rather than just not having that kind of optimization implemented. If we write 'x % 6 && x % 3', the compiler pointlessly generates both operations. And GCC generates branchless code for 'is_divisible_by_6', which is just worse than 'is_divisible_by_6_optimal' in all cases.

  bool is_divisible_by_15(int x) {
      return x % 3 == 0 && x % 5 == 0;
  }

  bool is_divisible_by_15_optimal(int x) {
      return x % 15 == 0;
  }

  is_divisible_by_15(int):
        imul    eax, edi, -1431655765
        add     eax, 715827882
        cmp     eax, 1431655764
        jbe     .LBB0_2
        xor     eax, eax
        ret
  .LBB0_2:
        imul    eax, edi, -858993459
        add     eax, 429496729
        cmp     eax, 858993459
        setb    al
        ret

  is_divisible_by_15_optimal(int):
        imul    eax, edi, -286331153
        add     eax, 143165576
        cmp     eax, 286331153
        setb    al
        ret

The examples are fun, but rather than yet another article saying how amazing optimizing compilers are (they are, I already know), I'd probably benefit more from an article explaining when obvious optimizations are missed and what to do about it.

Some boring examples I've just thought of...

eg 1:

    int bar(int num) { return num / 2; }

Doesn't get optimized to a single shift right, because the that won't work if num is negative. In this case we can change the ints to unsigneds to tell the compiler we know the number isn't negative. But it isn't always easy to express to the compiler everything you know about your data and use case. There is an art in knowing what kinds of things you need to tell the compiler in order to unlock optimizations.

eg 2:

    int foo(void) { return strlen("hello"); }

We all know that strlen will return 5, but some compilers don't: https://godbolt.org/z/M7x5qraE6

eg 3:

    int foo(char const *s) {
      if (strlen(s) < 3) return 0;
      if (strcmp(s, "hello") == 0)
        return 1;
      return 0;
    }

This function returns 1 if s is "hello". 0 otherwise. I've added a pointless strlen(). It seems like no compiler is clever enough to remove it. https://godbolt.org/z/Koj65eo5K. I can think of many reasons the compiler isn't able to spot this.

  bool is_divisible_by_6(int x) {
      return x % 2 == 0 && x % 3 == 0;
  }

  bool is_divisible_by_6_optimal(int x) {
      return x % 6 == 0;
  }

I don't know enough about ASM. Are u saying the first one is more optimal because it is faster or because it uses less instructions? Would this reflect a real world use case? Do any other compilers (e.g. V8) optimize modulo's into something else?

Those aren't isomorphic. The C spec says `is_divisible_by_6` short-circuits. You don't want the compiler optimising away null checks.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf

6.5.13, semantics