I do it all the time. It finds errors CC doesn’t. Especially in math formulas. I ping pong reviews between the two agents until they converge on no errors.
It’s not gobbledygook. I think for most people it’s hard to grasp the scale of the entire industries outside of their area of professional expertise so you can look at some numbers here:
In fact this a crux of the problem in low latency code and there are ways to combat this.
I know there is an academic wait-free and lock-free definition but folks use those often incorrectly as a slogan that something is magically better because it’s „lockfree”.
Imagine how _you_ would implement a read-modify-write atomic in the CPU and why E stands for exclusive (sort of like exclusive in a mutex)
Yes. [1] has background, [2] has the implementation (fig 2. pseudocode). Since you understood my comment I trust you can figure out the rest :) it’s a very neat trick.
There is one more way that is truly lock free. Most lock free implementations relying on atomic compare and swap instructions are not lock free afaik; they have a lock on the cache line in the CPU (in a way you go away from global lock to many distributed locks).
There is one more mechanism that allows implementing ring buffers without having to compare head and tail buffers at all (and doesn’t rely on counters or empty/full flags etc) that piggybacks on the cache consistency protocol
The workaround is for everyone to coordinate , print and mail physical returns. Let IRS have fun with scanning and processing :) enough people do this, IRS would open up digital filing again
it’s a known effect. Without going into details here, you can calculate first crossing time of a barrier in a stochastic process and observe that often the first crossing time decreases as the volatility increases. From there you can set one barrier at 0 (default) and draw your own conclusion.