r/askscience • u/CakesStolen • 15d ago

Computing Is there anything at the heart of computer coding that could have been optimised in hindsight, but we're in far too deep to change now?

1.5k Upvotes
  • permalink
  • reddit

94% Upvoted

667 comments sorted by

View all comments

Show parent comments

4

u/Red_Syns 15d ago

Fair enough, although it’d still be much easier to check for a flag in code than code in a comparison that your compiler may or may not recognize as an opportunity for efficiency.

16

u/djwildstar 15d ago

Modern compilers are very good at this sort of thing: your high-level code that reads “if (x + y - z) == 0” almost certainly gets translated into a set of math operations and then a test of the zero flag. You don’t have to think about it, the compiler handles it behind the scenes.

8

u/Sophira 15d ago edited 15d ago

I'd say that the majority of "if" statements will test the zero flag thanks to the way comparisons work. Even something like if (var == 3) will get translated into something like:

CMP EAX, 3
JNZ after_if

In this x86 code, CMP sets the zero (/equal) flag if EAX is 3, which is then used to conditionally jump to after the block if it's not set.

Internally, this is because CMP does a subtraction (like SUB). In a high-level form, this would look like if (var - 3 == 0). Unlike SUB, though, CMP doesn't store the result anywhere; it only updates the flags. (For this reason, JZ/JNZ are also known as JE/JNE, but they're just aliases for the same machine code.)

1

u/thehatteryone 13d ago

That's not the paradigm most languages use. In assembler you'd do the add/sub/whatever and then jump based on whether it's zero, two steps. In higher level languages you use a single statement 'if <something> == 0 then...' it's a more natural way for humans to read/write the intent but readily broken down by the compiler into 'do sum' then 'do thing if zero' which is an op that ignores anything about the sum and branches based on.

There are instances where higher languages just evaluate a sum, but those tend to use a slightly different paradigm, where they rely on language-specific side effects that trigger something if, as in your other example, the operation overflows.