mibsl

"good"

EDIT: And don't get me wrong, I hope it doesn't happen for a long time, ideally never. But what would his arguments be if it does?

Too early to tell, but IMO unlikely. Let's see what his take will be once an AI can propose a topic, write the script, animate, and narrate a good educational math video.

APIs are code. Describing them in prose feels like going back to alchemy from chemistry.

~45% of people work for companies of less than 500 people, ~12% for the govrnment (federal, state, local), ~6% are self employed. That leaves less than a half for all the companies >500, and only a tiny minority of them have an outsized influence on politics.

EDIT: Also, if there were no big corporations, people would still work and pay taxes. No sane statesman would purposefully build their countries economy on non-state-controlled megacorps.

Over 80% of the federal government's revenue comes from individuals (income tax, payroll tax).

On the other hand, I guess the vast majority of politician incomes come from corporations.

For me, unstructured things (like non-formal diagrams, notes, pseudocode) are close to useless. I much prefer sketching the API surface in code right away and then iterating on it, building abstractions which cut the shapeless thought blob into neat, predictably interacting parts. The code is my notepad and the compiler is with me, every step of the way, catching contradictions and handwavyness.

I'd say, in this analagy, step two is filling in half the numbers by gut feeling, and then three is seeing how wrong the guesses were and actually solving it.

Also, the default collector, G1, introduced more than 15 years ago. Most JVM GCs are concurrent, too.

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).