The less complex sections were mostly on-par with other us cities.

Increased insider trading will increase spreads.

That's not actually the predicted odds by the market because every single bet is also a bet on interest rates.

A contract that literally 100% always would resolve to "true" in 1 year would have a non-zero price for the "false" side because selling that option (and thus taking the "false" side means you get ~$97 today and then pay $100 in a year.

Polymarket's 4% chance of jesus returning by 2026 actually represents a market consensus of basically a 0% chance.

For trump losing office there might be some bets predicated on his losing office being correlated to a higher interest rate outcome, too.

It's also socket activated, which is nice.

It doesn't mean there's a 16% chance.

It's probably more attractive to gamblers when presented like this.

iPhone users are kinda out of luck, but the autoeq database can show you how to set Music's equalizer to approximate a flat response

Idle threads do increase the amount of committed stack. Once their stack grows it stays grown, it's not common to unmap the end and shrink the stacks. In a system without overcommit these stacks will contribute to total reserved phys/swap in the child, though ofc the pages will be cow.

> Windows employs a distinct process/thread design, making the UNIX concept of a process foreign. Threads are the primary construct in Windows and the kernel is highly optimised for thread management rather than processes. Cygwin has outlined significant challenges in supporting fork(2) semantics on Windows and has extensively documented the associated difficulties. However, I am veering off-topic.

The nt kernel actually works similarly to Linux w.r.t. processes and threads. Internally they are the same thing. The userspace is what makes process creation slow. Actually thread creation is also much slower than on Linux, but it's better than processes. Defender also contributes to the problems here.

Windows can do cow mappings, fork might even be implementable with undocumented APIs. Exec is essentially impossible though. You can't change the identity of a process like that without changing the PID and handles.

Fun fact: the clone syscall will let you create a new task that both shares VM and keeps the same stack as the parent. Chaos results, but it is fun. You used to be able to share your PID with the parent too, which also caused much destruction.

Usually the problem is an unfortunately placed spill, so the operation is actually l1d$ traffic, but still.

Thread stacks come up because reserving them completely ahead of time would incur large amounts of memory usage. Typically they start small and grow when you touch the guards. This is a form of overcommit. Even windows dynamically grows stacks like this

Fact is that by the time small allocations are failing you are almost no better off handling the null than you would be handling segfaults and the sigterms from the killer.

Often for servers performance will fall off a cliff long before the oom killer is needed, too.

Obviously if there's safety issues but for stimulants unsafe doses will 100% always decrease performance, because they'll affect sleep.