cokernel_hacker

The actual paper is:

"The Geometry of Color in the Light of a Non-Riemannian Space"

https://onlinelibrary.wiley.com/doi/10.1111/cgf.70136

It seems he is still active in the bioinformatics space: https://github.com/thegenemyers/FASTK

What if it breaks in a way which renders it no longer a chair for you but not others?

This seems to imply that what is or is not a chair is a subjective or conditional.

It was almost certainly added in order to support EFI which uses PE/COFF format binaries.

Internal DACs/amps have gotten a lot better, at least in Apple products.

https://support.apple.com/en-us/108351

https://www.audiosciencereview.com/forum/index.php?threads/r...

ARM has DIT: https://developer.arm.com/documentation/ddi0595/2021-06/AArc...

Intel has DOIT: https://www.intel.com/content/www/us/en/developer/articles/t...

The idea is that the processor will not take shortcuts that take advantage of the values it is processing. For example, a 64-bit division cannot shortcut if the operands are both small, etc.

With chip fabrication technology in the spotlight lately, this book chapter on the history of EUV development and DARPA's role might be of interest to some.

So let's change it up a bit.

  typedef int (*pfn)(void);
  int g(void);
  int h(void);

  pfn f(double x) {
    switch ((long long)x) {
    case 0:
      return g;
    case 17:
      return h;
    }
  }

If I understand your perspective correctly, `f` should return whatever happens to be in rax if the caller does not pass in a number which truncates to 0 or 17?

What behavior should the following have:

  int f(int x) {
    switch (x) {
    case 0:
      return 31;
    case 1:
      return 28;
    case 2:
      return 30;
    }
  }

This code on its own has no undefined behavior.

In another translation unit, someone calls `f(3)`. What would you have compilers do in that case?

That path through the program has undefined behavior. However, the two translation units are separate and as such normal tooling will not be able to detect any sort of UB without some kind of whole program static analysis or heavy instrumentation which would harm performance.

That works for a lot of behavior but not everything. For example:

  int f(int x) {
    static int y[] = {42, 43};
    return y[x];
  }

What behavior should `f(-1)` or `f(100)` have? What is sensible?

This python actually builds a graph under the hood which then gets JIT compiled for CPU/GPU/TPU.