hun3

> if your framework's value can be replicated by targeting its test suite,

Side note: this is also why SQLite's full test suite is proprietary / private

https://sqlite.org/th3.html

Except that merely surfacing them changes their behavior, like how you add that one printf() call and now your heisenbug is suddenly nonexistent

eke*

(yes, I'm dying on this hill)

Mostly depends on how bloat correlates to attack surface, but you're right

The size feels like you can almost fit it in a L3 Cache-As-RAM

Sure, as long as you don't run out of `s

Hypervisor as a microkernel

Stripping away unused drivers (.config) and other "bloats" can get you surprisingly far.

Then the question becomes: to what extent do you trust Xen and Qubes RPC?

Verified software should satisfy the liveness property; otherwise, an infinite loop that never returns would pass as "correct."

Verifying realtime software goes even further and enforces an upper bound on the maximum number of ticks it takes to complete the algorithm in all cases.

Just append

  X-Crawl-Reason: Finding spare license plates, throttled ONLY to prevent service disruption. To the best of my knowledge, [legalese claiming good faith and compliance to all applicable laws]

(Mandatory disclaimer: IANAL, ignorance is no excuse for breaking laws)

> Code is an asset.

Funnily enough, this doesn't contradict "code is debt" because Asset = Equity + Liability.

My next malloc(3) is returning NAN.

maybe REST? I think a proper REST system of APIs is designed to be discoverable.

Probably something like

  Error: stepping, NOT NULL constraint failed: messages.dkim (19)

because, unlike MySQL, SQLite apparently returns SQL NULL for JSON null value.

I think we're going a bit past each other.

In AVR or other MPU-less architecture you can literally modify the string literal memory without triggering a crash.

Why? Because there is no memory protection ("rodata") at all.

And such microprocessors are still in use today, so it's a bit too far fetched to say "really old code."

It's UB, sure, but how many embedded programmers actually care? The OP's proposal is trying to change the type system so that this UB becomes much less likely to trigger in practice.

The affected platforms lack an OS (e.g., bootloaders) and/or an MMU/MPU (e.g., microprocessors like AVR)

Quoting a paragraph from OP (https://www.anthropic.com/research/tracing-thoughts-language...):

> Sometimes, this sort of “misfire” of the “known answer” circuit happens naturally, without us intervening, resulting in a hallucination. In our paper, we show that such misfires can occur when Claude recognizes a name but doesn't know anything else about that person. In cases like this, the “known entity” feature might still activate, and then suppress the default "don't know" feature—in this case incorrectly. Once the model has decided that it needs to answer the question, it proceeds to confabulate: to generate a plausible—but unfortunately untrue—response.

WinRing0 is associated with CVE-2020-14979 where any local program can take complete control (NT AUTHORITY\SYSTEM) over your system: https://nvd.nist.gov/vuln/detail/cve-2020-14979

It is possible, although not confirmed, that the block was motivated by an ongoing malware threat that involves this particular threat, but take this with a grain of salt.

-O3 does autovectorization: turning your loops into a bunch of SIMD instructions, sometimes even drastically changing performance profile.

If autovectorization is "not that much magic" then idk what else it is.

At least it's one day off from 996.icu

for now.

Tangentially related: https://sqlite.org/purchase/license

idk, losing access to preinstalled OEM license?

Or VBA, which has Empty, Null, and Nothing:

https://excelbaby.com/learn/the-difference-between-empty-nul...

(and sometimes Missing)

(2016)

Have fun brute forcing heisenbugs and LLM hallucinations

See also: word embedding and sentence embedding models

Not really. MMIO mapped at 0x0 for example.

> The ping backed memory storage

It's worth noting that this is a network reincarnation of the old tried-and-true delay-line memory.

https://en.wikipedia.org/wiki/Delay-line_memory