mibsl

Why not go further - learning is doing, not consuming (reading, watching, listening)?

5,283 workers were killed on the job in the United States in 2023.

The only thing capital owners risk is losing it and becoming a worker.

Probably "/s", if I had to guess.

AFAIU antirez is mostly writing in C, a verbose language where "create a hashtable of x->y" turns into a wall of boilerplate. In high level languages the length diffrence between a precise specification and the actual code is much smaller.

It seems actively maintained, latest build on Flathub is from 3 hours ago.

Being always cognizant of opportunity costs also has an opportunity cost in terms of mental health and life satisfaction.

IIRC genetic drift can reach 100%.

There is still glass (and silicone?).

I think Haskell's Software Transactional Memory has used this novel write-snapshot isolation level for close to two decades.

This is done so that the programmer doesn't have to reason about it. Polonius makes the compiler accept code that's obviously valid, but the current borrow checker isn't sophisticated enough to declare it as safe.

I've bumped into this kind of problem when writing rust, at first it was hard to understand why the compiler doesn't accept my code.

The problem described in 2018 seems completely unrelated to downfall. It looks like a potential optimization to the original spectre, doesn't even mention AVX gather instructions.

I don't see this going anywhere.

To me this one feels cluttered, way too much going on. Definitely distracting, but I wouldn't call it beautiful.

Not really. The NH D15 is an impressive cooler, but it falls behind 280 AIOs. Even ones cheaper than itself.

https://www.gamersnexus.net/hwreviews/3571-arctic-liquid-fre...

Semiconductors - Physics inside Transistors and Diodes

Physics Videos by Eugene Khutoryansky

https://www.youtube.com/watch?v=hrpPKCDLRN0

The code snippets appear to be full of mistakes.

E. g. filter_vec_avx2 doesn't declare the loop variable i and stores input elements into the output instead of their indices. Or from_u32x8 has a DataType instead of __m256i and [u32; __m256i] instead of [u32; 8].

Meaningless because (adequately cooled) modern desktop CPUs mostly run near their boost clock in single threaded loads and somewhere between base and boost in multithreaded.

Short circuiting is a special case of laziness. It's local only, so no thunks are required.

The beauty of functions like fromMaybe is they're only that - just plain, regular functions. No special casing under the hood required.

Only tail recursion, not tail calls in general.

Compilers can easily lower tail recursion into loops, but not general tail calls between arbitrary (possibly unknown, indirect) functions.

The best they can do are trampolines, which come with a high performance cost.

Haskell's IO monad actually has excellent exception support, including async exceptions and masking them in critical sections.

There are `Maybe` and `Either` and they're great at streamlining error handling in pure code, but when it comes to IO most libraries just throw exceptions (including the standard library).

To maximize I$ hit rate you'd actually want to disable loop alignment to not inflate code size with padding.

Here's an example of unstable benchmark performance caused by the lack of code alignment in .NET's JIT: https://github.com/dotnet/runtime/issues/43227

Just a guess, but it kind of sounds like machine code loop alignment could be the cause. Modern CPUs really like their jump targets 32 byte aligned.