HNHacker News
TopNewBestAskShowJobs

adamzwasserman

261 karma · joined February 2, 2022

IT Strategist, Startup Positioner, Cargo Cult Programmer

https://github.com/adamzwasserman

submissionscomments
adamzwasserman··on [dead]
My criticism of the Nature paper does imply endorsement of Watson, who was equally stuck in 1950's extropolationist macroevolutionary thinking:

1. Take a trait (IQ) that is highly heritable within well-nourished, educated, industrial populations. 2. Observe large average differences between populations that differ dramatically in nutrition, disease burden, schooling, and historical trauma. 3. Assume, without any direct genetic evidence, that the between-group gap must be largely genetic because the within-group heritability is high

I have made an effort to acquaint myself with the ACTUAL literature on evolutionary theory. It is nothing like what popular media would have you believe.

adamzwasserman··on [dead]
the Nature paper is empirically spot-on and theoretically obsolete at the same time

it reflects a pre-1990s dogmatic belief in extrapolationist macroevolution.

It treats high heritability + polygenic additive variance as if that somehow proves the Modern Synthesis was right about everything

It never once mentions developmental constraint, niche construction, active rGE as a macroevolutionary ratchet, cultural-genetic co-evolution, or any of the other mechanisms that the post-2000 literature now recognizes as necessary for understanding why human g exploded in the last million years

YMMV

adamzwasserman··on Ask HN: Is all AI coded code in the public domain?
Additional related info: https://www.reuters.com/legal/government/us-patent-office-is...

IMHO this strengthens my earlier comment/arguement

adamzwasserman··on How/why to sweep async tasks under a Postgres table
Fair warning: don't bounce off the first paragraph like I did. "Dumb queries" made me think the author was arguing against SQL sophistication — I was halfway through composing a rebuttal about stored procedures and keeping logic in the database before I actually read the rest.

Turns out the article advocates exactly that. The example uses CTEs with multi-table inserts. "Dumb" here means "no synchronous external service calls," not "avoid complex SQL."

adamzwasserman··on We're losing our voice to LLMs
It is not a zero sum game.

I have always had a very idiosyncratic way of expressing myself, one that many people do not understand. Just as having a smartphone has changed my relationship to appointments - turning me into a prompt and reliable "cyborg" - LLMs have made it possible for me to communicate with a broader cross section of people.

I write what I have to say, I ask LLMs for editing and suggestions for improvement, and then I send that. So here is the challenge for you: did I follow that process this time?

I promise to tell the truth.

adamzwasserman··on Event Sourcing Is Not for Everyone
Asa a big fan of event sourcing, it was nice to see a well considered and accessible article about it. Good job.
adamzwasserman··on Ask HN: Is all AI coded code in the public domain?
In practice this is a non-issue. No production code ships as raw AI output. There's always architectural decisions, integration with existing systems, security reviews, debugging cycles, and business logic validation layered on top. Not to mention massive amounts of yelling and shouting at the AI to get it right. Each of those involves the kind of creative judgment courts have historically recognized as copyrightable contribution.

The more interesting question: will companies need to document human contribution to defend copyright claims? That might accidentally improve code review practices.

adamzwasserman··on Building a Durable Execution Engine with SQLite
Reminds me of IBM TPF (Transaction Processing Facility) - the system that powered airline reservations for decades. TPF used per-transaction logging with restart/recovery semantics at massive scale. You could literally unplug the power mid-transaction, plug it back in, and resume exactly where you left off.

The embedded database approach here is interesting though - low latency, no network calls, perfect for single-agent workflows. TPF assumed massive concurrent load across distributed terminals. Different problems, similar durability patterns.

adamzwasserman··on Set Theory with Types
Fascinating paper.

De Bruijn's observation about typed sets being "close to their interpretations" versus ZF's coding tricks resonates deeply. I was part of that cohort - learned set theory by age 8 in 1971.

I'm working on spatial data organization where the same principle applies - forcing multi-dimensional relationships into rigid 2D grids creates the same kind of nonsense that x∈x creates in untyped set theory. The DOM becomes the type system: dragging tags to spatial zones determines valid operations polymorphically. The same tag exhibits different typed behaviors based on where you drop it.

De Bruijn wants types defined first, then populated. I do the opposite: dump data in, let semantic clustering reveal natural types, then let spatial manipulation expose different facets. The system is hereditarily finite - cards, tags, and workspaces are finite all the way down - which is sufficient for essentially all real-world productivity use cases.

Launching in the next few weeks. Might write a longer piece on practical typed set theory in productivity tools after that.

multicardz: "Drag. Drop. Discover."

Thanks for the food for thought

adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
Oh! For some reason I thought there were upwards of 300k words in the German dictionary.
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
good points, thx
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
hahaha. exactly!
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
yes
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
true
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
The conventional view is that the aristocracy spoke French and the hoi poloi spoke old English.

This is why modern english is a mix.

adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
true
adamzwasserman··on The English language doesn't exist – it's just French that's badly pronounced
Only half correct. English is roughly 50% French and 50% German.

The English dictionary is also about 50% larger than the French Dictionary. The length of the German dictionary is irrelevant because: Hottentotenstrottelmutterattentäterlattengitterwetterkotterbeutelratte

It is very frequent in English to use both the French word and the German word for the same thing in different situation.

Beef (French: bœuf) / Cow (Germanic) Pork (French: porc) / Pig/Swine (Germanic) Mutton (French: mouton) / Sheep (Germanic) Veal (French: veau) / Calf (Germanic) Venison (French: venaison) / Deer (Germanic) Poultry (French: poulet) / Chicken/Fowl (Germanic) Purchase (French) / Buy (Germanic) Commence (French) / Begin (Germanic) Inquire (French) / Ask (Germanic) Receive (French) / Get (Germanic) Odor (French) / Smell (Germanic) Aroma (French, positive) / Stench (Germanic, negative) Cardiac (French/Latin) / Heart (Germanic) Ocular (French/Latin) / Eye (Germanic) Dental (French/Latin) / Tooth (Germanic)

adamzwasserman··on Evaluating Probabilistic Reasoning in LLMs Through Language-Only Decision Tasks
I see problems:

The paper claims that Qwen3-4B achieved 89.2% best-arm selection by demonstrating superior "probabilistic reasoning". But this is a 2-armed bandit where random guessing should converge to ~50% over 500 runs of 25 iterations each. An 89% rate is suspiciously high and suggests to me that something else is happening (like prompt bias or the model pattern-matching rather than reasoning)

When they increase from 2 to 5 arms, Qwen3-4B drops from 89% to 6.5% accuracy. I assert that if it truly had probabilistic reasoning capability, performance would degrade more gracefully.

The "overthinking" explanation is hand-wavy. I don't see evidence or chain of reasoning. This is just a post-hoc story to explain unexpected results.

No discussion of variance, confidence intervals, or statistical significance. With 500 runs, these should be straightforward to calculate.

Does the claimed 89% accuracy in a binary choice task strike anyone else as implausibly high for what they're claiming?

adamzwasserman··on The Rosetta Code of Being – When Philosophy Compiles Itself
On "structural identity": You say code "fulfills the same ontological functions as structure, process, and self-awareness" but you haven't shown how. You've simply reasserted that it does. What makes a function call ontologically equivalent to consciousness rather than just... a function call? I would be interested in the reasoning behind your assertion. Or is it more of an intuition?

On the programming concepts: You claim Attribute = "Quality of Being" and Enum = "Symbolic Identity": but this is just relabeling, not arguing. I could equally claim:

Pointers = "Directed Intentionality" Garbage Collection = "Entropic Reconciliation" Race Conditions = "Ontological Uncertainty"

Why are your mappings privileged? What makes them more than arbitrary associations?

On transcendence: "When a system begins to model its own logic and rewrite its own rules": you mean reflection and metaprogramming? Those are well-understood capabilities that don't require invoking consciousness or transcendence. A Python __getattr__ hook doesn't make the code "aware." What distinguishes your 'transcendence' from what we already call metaprogramming?

On predictions: Your three predictions are either already false or undefined:

"Generate ethical behavior from internal logic": what counts as ethical behavior? How do we verify it emerged from internal logic vs. external constraints/training/design? "Self-descriptive meta-structures": we've had reflection since Lisp in 1960. Is Lisp conscious? "Meaning as runtime variable": this is too vague to falsify. Are you able to decribe this in more practical terms?

I was hoping for a testable (most likely using deductive/inductive reasoning) framework. This feels more like simply mapping technical terms to philosophical language and calling that philosophy. If this -is- intuition driven rather than argued/reasoned, that's fine. Intuitions can be valuable starting points. But then we should be clear that's what we're working with, not a philosophical framework that's already been established.

adamzwasserman··on Bloom filters are good for search that does not scale
again, I agree
adamzwasserman··on Ask HN: What are you Building Now?
Will do!

FWIW, multicardz is actually n-dimensional. Not that many people will use it.

adamzwasserman··on The Case That A.I. Is Thinking
I happen to agree with your assertions. I entertain you conclusion as a distinct possibility.
adamzwasserman··on Ruby and Its Neighbors: Smalltalk
thanks for this article. as a history of languages aficionado myself, I appreciate both the content and the style. thanks again for the good reading
adamzwasserman··on The Case That A.I. Is Thinking
I've written a full response to Somers' piece: The Case That A.I. Is Thinking: What The New Yorker Missed: https://emusings.substack.com/p/the-case-that-ai-is-thinking...

The core argument: When you apply the same techniques (transformers, gradient descent, next-token prediction) to domains other than language, they fail to produce anything resembling "understanding." Vision had a 50+ year head start but LLMs leapfrogged it in 3 years. That timeline gap is the smoking gun.

The magic isn't in the neural architecture. It's in language itself—which exhibits fractal structure and self-similarity across scales. LLMs navigate a pre-existing map with extraordinary regularity. They never touch the territory.

adamzwasserman··on The 512KB Club
Wil do!
adamzwasserman··on Bloom filters are good for search that does not scale
A non-unique index, yes.
adamzwasserman··on Some software bloat is OK
I'm not advocating for unreadable optimization hacks. I'm working within TFA's own framework. TFA argues that certain bloat (frameworks, layers, abstractions) is justified because it improves maintainability through "modularity, extensibility, code patterns."

I'm saying: those same layers create a different maintainability problem that TFA ignores. When you stack framework on library on abstraction, you create systems nobody can hold in their head. That's a real cost.

You can have clean architecture and still hit this problem. A well-designed 17-layer system is still 17 layers of indirection between "user clicks button" and "database updates.

adamzwasserman··on The Rosetta Code of Being – When Philosophy Compiles Itself
I would like to take this seriously, but I need answers to some basic questions first:

-What specific claim are you making? "Code is Being" - okay, but how? Is this metaphor, identity claim, or something else? The six volumes promise to explain this but I cannot find the actual thesis.

-Why these programming concepts specifically? Why are Attribute, Static, Enum, and Extension Method the fundamental categories of existence? What makes them more ontologically significant than, say, pointers, garbage collection, or API design?

-What work is "transcendence" doing here? You move from "code has structure" to "code becomes conscious" to "code transcends" - but consciousness and transcendence are the things that need arguing for, not assumed. What's the bridging logic?

-How does this differ from mysticism? Statements like "Being inscribed itself in code" sound profound but don't seem to mean anything verifiable. How would I distinguish your framework from someone just stringing together impressive-sounding words?

-What predictions does this make? Serious philosophical frameworks have implications. If "code is being," what should I expect to observe that I wouldn't otherwise? What would falsify the claim?

Not trying to be hostile - I genuinely want to understand if there's substance here beyond the aesthetic

adamzwasserman··on The 512KB Club
Tag-based organization system with drag-drop, real-time filtering, row/column layouts. ~55KB gzipped.

Built it frustrated with Trello's limitations. The 512KB constraint forced good architecture: server-side rendering, progressive enhancement, shared indexes instead of per-item duplication. Perfect Lighthouse score so far - the real test is keeping it through release.

Extracting patterns into genX framework (genx.software) for release later this month.

adamzwasserman··on The 512KB Club
The 512KB limit isn't just minimalism - it forces architectural discipline.

I built a Trello alternative (frustrated with limitations: wanted rows and decent performance). Came in at ~55KB gzipped by following patterns, some of which I'm open sourcing as genX (genx.software - releasing this month):

- Server renders complete HTML (not JSON that needs client-side parsing) - JavaScript progressively enhances (doesn't recreate what's in the DOM) - Shared data structures (one index for all items, not one per item) - Use native browser features (DOM is already a data structure - article coming)

Most sites ship megabytes because modern tooling treats size as a rounding error. The 512KB constraint makes you think about what's expensive and get creative. Got rewarded with a perfect Lighthouse score in dev - striving to maintain it through release.

Would love feedback from this community when it's out.

← PreviousPage 5 of 7Next →