I used to get terrible eye strain, causing fatigue and sleepiness. Obviously not good.

Then I bought a Saab 900. It had a 'night mode' that disabled all dials except the speedo. The lights went off and the dial went down. (It came back on if it needed to alert you of something, say low fuel.) [0]

This made a radical difference, and led me to the dash-brightness dial that nobody ever touches. Turns out if you turn that way down, reducing the contrast between you and the road, it's actually enough to get you 90% there. Because you probably don't drive a 1992 Saab (more's the pity).

[0]: https://www.youtube.com/watch?v=KIfzUqYEkiw

The max clock skew also has to pick between A and C, in underestimates you lose serializability, in overestimates you pay in write latency.

Sounds like a standard "democratic leader" these days.

Allocation is perceived as slow because it is. Getting memory from the OS is somewhat expensive because a page of memory needs to be allocated and stored off. Getting memory from traditional allocators is expensive because freespace needs to be tracked. When you say "I need 5 bytes" the allocator needs to find 5 free bytes to give back to you.

Bump allocators are fast because the operation of "I need 5 bytes" is incrementing the allocation pointer forward by 5 bytes and maybe doing a new page allocation if that's exhausted.

GC allocators are fast because they are generally bump allocators! The only difference is that when exhaustion happens the GC says "I need to run a GC".

Traditional allocators are a bit slower because they are typically something like an arena with skiplists used to find free space. When you free up memory, that skiplist needs to be updated.

But further, unlike bump and GC allocators another fault of traditional allocators is they have a tendency to scatter memory which has a negative impact on CPU cache performance. With the assumption that related memory tends to be allocated at the same time, GCs and bump allocators will colocate memory. But, because of the skiplist, traditional allocators will scattershot allocations to avoid free memory fragmentation.

All this said, for most apps this doesn't matter a whole lot. However, if you are doing a CPU/memory intense operation then this is stuff to know.

Really it's allocators in general. Allocations are perceived as expensive only because they are mostly dependent on the amortized cost of prior deallocations. As an extreme example, even GCs can be fast if you avoid deallocation because most typically have a long-lived object heap that rarely gets collected - so if you keep things around that can be long-lived (pooling) their cost mostly goes away.

https://alexbsoft.github.io/win95.css/ windows 95

https://botoxparty.github.io/XP.css/ windows xp

https://cs16.samke.me/ counter strike 1.6

https://edwardtufte.github.io/tufte-css/ edward tufte

https://jdan.github.io/98.css/ windows 98

https://khang-nd.github.io/7.css/ windows 7

https://micah5.github.io/PSone.css/ playstation one

https://nostalgic-css.github.io/NES.css/ nes

https://sakofchit.github.io/system.css/ apple system

https://thesimscss.inbn.dev/ the sims

Why is the discussion so rarely focused on the fact that your boss can demand that you uplift your life or else you're fired, immediately and with impunity, and what you have to say about it means absolutely nothing?

Maybe I am baffled by this because I live and work in Europe where the relationship is a bit better (though I am not sure for how much longer it will remain as such). Americans seem very content to allow this behavior as normal because, obviously, other employees (but not me, I am a great employee!) must serve their stakeholders better so we can gain every bit of efficiency and increase precious income in the economy.

There were non-cheap calculators in the 1980s, too, that did proper evaluation. The ones I remember had keys for parentheses, though, allowing you to enter, for example

  (3 + 4) * 7 =

For an example see the TI-25 at http://www.datamath.org/Sci/Slimline/TI-25.htm

The calculator built into Windows (at least back then, maybe they’ve changed it), gave 9 to my test instead of 7.

⸻

1. If they got some number other than 9 or 7, I recommended dousing it in holy water, and then gasoline, burning it, encasing the ashes in concrete and dropping that concrete block into the deepest part of the ocean because that calculator is cursed.

I do usually prefer the latter behavior, but without it being displayed as in more advanced calculators (it has been changed to show it) it's just not what I would expect at all, resulting in wrong calculations. But maybe it was just a "me-problem".