4 Billion If Statements (2023)

https://news.ycombinator.com/item?id=38790597

4B If Statements (469 comments)

Amazing!

Thanks for making me doubt myself & googling who that guy who made python was again, because surely "van der Gussom" isn't a normal Dutch name. Well played.

else

So if you're concerned with privacy issues, you can run the assembly version proposed in the article locally and be well within the same order of performance.

Let's thank the author of the article for providing a decent alternative to Google.

ah, but the license is not that good we can't reproduce his code.

  for i in range(2*8):
    if i % 2 == 0:

Optimization efforts included increasing the internal buffer size of the StreamWriter used to create the source code: this reduced the runtime to around 6 minutes, as well as running a non-debug build, as it was observed that the poor Visual Studio metrics gathering process was contributing significantly to disk activity as well, but that ultimately didn't matter much. So, ehhm, yes, good job on that I guess?

Am I lost? Aren't the compiler/linker responsible for fast code, not the language itself?

If anyone knows what’s actually going on, please do tell.

    switch (v) {
     case: 0,2,4,8,…:
       return EVEN;
     case: 1,3,5,7,…:
       return ODD;
     default:
       return IDK;
    }

    return odd_or_evenness[n];

Or even simpler: If it's 0, return "even". If not, do a recursive call to n-1, if that equals "even", return "odd", otherwise return "even".

But the best way is probably to just use a library. Yes, 500MB of additional dependencies, but then it's a one-liner.

I was gonna comment “this is what I really like to see on HN”. Then I saw the date and was sad that we’re having to dip into the history box to find fun/interesting articles more often of late it seems.

Anyone else interested in a temporary moratorium on all things LLM? We could have GPT-free-Wednesday, or something like that :)

The best way to save space is to use a Bloom Filter.

If we capture all the even numbers, that would sadly only give us "Definitely not Even" or "Maybe Even".

But for just the cost of doubling our space, we can use two Bloom filters!

So we can construct one bloom filter capturing even numbers, and another bloom filter capturing odd numbers.

Now we have "Definitely not Even" and "Maybe Even" but also "Definitely not Odd" and "Maybe Odd".

In this manner, we can use the "evens" filter to find the odd numbers and the "odds" filter to find the even numbers.

Having done this, we'll be left with just a handful of unlucky numbers that are recorded as both "Maybe even" and "Maybe odd". These will surely be few enough in number that we can special case these in our if/else block.

The filters as a first-pass will save gigabytes of memory!

I started designing my modules, a ROM, a register with a ROM pointer, etc, etc, writing the Verilog and working out the clock sync between modules. Then I got 'lazy' and wrote a trie tree like implementation in Java, and have it spit out the whole tree in Verilog. It worked and just one clock cycle after the last letter my number would output. Fastest in the class! Also the most number of gates in the class. Surprised I got a 90 grade given I didn't use any of the advanced ASIC design the class taught. The TA didn't know what the hell they were looking at.

isEven is a performant, hand-compiled evenness checker for any 32 bit integer. A single file import that does one job and one job only!

Save space.

  def even_flip_flop(number):
    even = True
    for _ in range(number):
      even = not even
    return even

  def even_recursive(number):
    return True if number == 0 else not even_recursive(number - 1)

  table = [True, False] * 1000  # adjust to your needs
  def even_lookup(number):
    return table[number]

    File.write("check.rb", (["if i == 0\n  puts :even"] + (1..1_000_000).map { |i| "elsif i == #{i}\n  puts :#{i % 2 == 0 ? "even" : "odd"}" } + ["end\n"]).join("\n"))

    i = ARGV.first.to_i

    fish: Job 1, 'ruby check.rb 0' terminated by signal SIGILL (Illegal instruction)

Moreover, interviewers will be smitten by the hand-optimized assembly code.

There was a function to detect a key press which would return a number identifying the pressed key.

I needed to map that number to the letter printed on the key to print it on the screen. I don't remember whether there was no hashmap data structure or I just didn't know about it, but I implemented it with a serie of if.

The problem with that solution is that while mapping A was fast, Z was very slow because it was at the end of the list. That is how I discovered divide and conquer/ dichotomy with if branches.

https://github.com/toji/gl-matrix/blob/master/dist/gl-matrix...

The technique actually has a lot of practical applications, so it's useful to have a C++ library that helps you with generating amd64 machine code.

    not     eax
    and     eax, 1

Wow he really lucked out... On his way to perfecting a fully functioning and performant Even/Odd Detector, he stumbled upon a fully functioning and performant Coin Flip Simulator!

Ok but if you do want to play with writing binary code manually I recommend Casey Muratori's performance course

Many gigabytes saved!

/s