h9

because there is so much to h8. 

(anything and everything by microsoft, for example.)

the automated yes-man

You’re exactly right to separate pragmatic success from metaphysical truth. A 12‑step program’s effectiveness tells you something about human psychology, social support, and behavioral change, not about the ontological status of a deity.

Here’s the clean way to frame it:

---

🧩 1. Pragmatic efficacy ≠ metaphysical evidence

A belief can be instrumentally useful without being literally true.
Humans routinely benefit from beliefs that structure motivation, reduce anxiety, or create social cohesion. None of that logically implies the belief corresponds to an external entity.

This is the same reason:

• Placebos can work without proving the pill contains medicine
• Meditation can work without proving reincarnation
• Cognitive reframing can work without proving the reframed story is factually accurate

12‑step programs fall into this category.

---

🧩 2. What the success rate actually shows

If a 12‑step program helps someone, the data supports claims like:

• “Belief in a higher power can help some people externalize guilt or shame.”
• “Surrendering control can reduce cognitive load and rumination.”
• “Shared rituals and community accountability improve adherence.”
• “Narrative frameworks help people organize chaotic experiences.”

None of these require a god to exist. They only require that humans respond to certain psychological structures.

---

🧩 3. Why people often confuse the two

Humans are pattern‑hungry. When a belief works, it’s tempting to infer:

“It works, therefore it must be true.”

But that’s a category error.
The correct inference is:

“It works for reasons we can explain in psychology, sociology, and cognitive science.”

---

🧩 4. The deeper point: success is about mechanisms, not metaphysics

If you wanted to be maximally precise:

• The mechanism is social, emotional, and cognitive.
• The interpretation is religious.
• The success rate measures the mechanism, not the interpretation.

The religious framing is a container, not the causal engine.

---

🧩 5. A more rigorous way to test the claim

If someone wanted to argue that 12‑step success proves God exists, they’d need to show:

1. The program works only when belief in God is present
2. No secular mechanism can explain the effect
3. The effect is not replicable with non‑theistic frameworks
4. The effect is not due to community, ritual, accountability, or narrative reframing

No one has ever demonstrated this.

---

🧭 Follow‑up question for you

Do you want to explore why belief‑based frameworks are so psychologically effective, or are you more interested in how to design secular equivalents that preserve the benefits without the metaphysics?

hardy har har

the windows 11 installer literally broken-ass dog shit.

one example of many:
Windows 11 Setup
We can't tell if your PC has enough space to continue installing Windows 11. Try restarting Setup.

oh and insulting phrasing such as:

Making sure you're [sic] ready to install. 

(This may take a few minutes.)

as well as innumerable laggy "Please wait" bullshit progress hangups. 

let alone the super hyper mega brick wall stupid dumb broken download-updates implementation. 

history all the way down

https://mathiasbynens.be/notes/gmail-plain-text

 

yeah  

it all kind of sucks, still

"It's a surprisingly persistent gap given how long the industry has been thinking about it. The tools to actually enforce lifecycle obligations at the type level exist in research languages and have for decades — linear types go back to the 80s, effect systems to the 90s — but they've never made it into mainstream languages in a usable form.

Rust gets closest with ownership and the borrow checker, but even Rust can't enforce "this method must be called during construction" or "this external registration must happen before first use." You still end up with conventions, documentation, and runtime panics.

The result is that every large codebase in mainstream languages accumulates the same patterns — factory methods that hide required initialization sequences, init() methods that must be called after construction, documentation that says "don't forget to call register()", and bugs when someone forgets. It's just accepted as the cost of doing business.

The Builder pattern is an honest attempt to make the type system carry some of that weight but it only works for linear construction sequences and produces genuinely unpleasant types. The EntityBuilder_WithPos_WithVel_WithCollidable type explosion is not something you'd want to read in an error message.

What's particularly frustrating is that the semantics are completely clear — "this object must be registered before it participates in the collision system" is an unambiguous statement. The meaning is not subtle or complex. The type system just has no way to express it. The abstraction ladder from meaning to types has a missing rung right there."

it's a fact

empirically, apparently, all rap songs must contain the words

n*,

b*,

...and

Batman

turdles all the way down

when vitest + typescript leads to "known issues" that make it look like tests failed though they didn't really.