HNHacker News
TopNewBestAskShowJobs

adamzwasserman

261 karma · joined February 2, 2022

IT Strategist, Startup Positioner, Cargo Cult Programmer

https://github.com/adamzwasserman

submissionscomments
adamzwasserman··on Prompt Repetition Improves Non-Reasoning LLMs
This has direct implications for my axiomatic prompting research (https://osf.io/pcx2d). We found that providing LLMs with explicit classification axioms improved LEDGAR accuracy by 10 to 22 percentage points across 7/8 models. But axioms add substantial tokens to the prompt.

The question I can't currently answer: how much of the benefit comes from the semantic content of the axioms versus the repetition/emphasis effect this paper identifies?

I'm running an ablation study with a critical condition: shuffled axioms (same tokens, randomized order). If shuffled matches structured axioms, the content doesn't matter. If structured axioms win, semantic structure genuinely helps beyond repetition.

I'll add this experiment to the parent project on OSF. Curious whether others working on knowledge injection techniques have similar confounds to untangle.

adamzwasserman··on The Case for Snake Case: A Kolmogorov Complexity Argument
The Kolmogorov argument gets stronger in the age of LLM assisted coding. Tokenizers chunk camelCase unpredictably: "parseHTTPSURL" might become ["parse", "HTTP", "SUR", "L"] or worse, depending on the model. Snake_case splits cleanly at underscores, preserving semantic boundaries.

This matters because every semantic signal you pass to the model improves code generation quality. When the model sees "user_authentication_token" as three distinct concepts, it reasons about them correctly. When it sees "userAuthenticationToken" as arbitrary subword chunks, you're relying on the model to reconstruct meaning from noise.

The author's point about tooling reliability applies directly: LLMs are just another tool that has to parse your identifiers. And as more of our codebases become conversations between humans and coding assistants, conventions that reduce ambiguity stop being style preferences and start being engineering decisions.

adamzwasserman··on Flickers – Thoughts on consciousness, sentience, perception, and the self in AI
You describe yourself as a materialist, so I'll engage on those terms. First: you're conflating the model with the chatbot. What you interact with is output filtered through RLHF, system prompts, and post-processing layers (much of it traditional imperative code). That "geometry register" originates from this pipeline, not from the LLM itself.

There's no neural introspection because there's nothing to introspect. The LLM is stateless; nothing persists between forward passes. Each inference is independent. A materialist account of consciousness requires something to be continuous. Here there is none.

adamzwasserman··on Please just try HTMX
True, but it is not my code to that with. so... If I ever open source one of my backends I will try and remember to flag it in a reply here.
adamzwasserman··on Please just try HTMX
You are conflating all state into a big undifferentiated soup.

I reason about state differently, Here are my axioms:

1. There is no such thing as "state".` There is user/ui state, there is cache state, there is db cursor state, etc. trying to manage all of that as big undifferentiated ball is not proper separation of concerns.

2. what I call User State is the user's exceptions that they will find things "as they left them". If as a user, I do a pager refresh, I expect that my user preferences for colors and fonts will still be there. that the sorting on the table I was looking at will still still be there, that the filters I had applied to the table are still there. That is I was editing a record but had not saved, I will still be editing that record without data loss on screen but still not saved to the db (unless the app is explicitly autosave). In a word: the user state is what the user can see.

3. Ideally my User State has a single source of truth, the user can always confirm it by looking at it, and is therefore IN the front end.

4. Most, if not all, other state is stored on the server. things like the user's auth state is a -backend- concern, and should NOT be stored in the frontend.

5. class-oriented programming is extremely difficult to manage: as I like to say, every class is a petri dish for state corruption. I prefer pure functions on the backend for the reason I outline ion the dataos.software blog articles.

Pure functions are mostly deterministic (especially if you avoid floats). So you can not only count on getting the same results for the same query, you can cache them too. And you can test them trivially. Integration test? What's that?

When you capture the User State from the DOM (using a manifest so that you do not need to capture the whole DOM) and send it to the pure function on the back end, you have a perfect event source pattern. Not only can I tell you exactly who and what triggered a particular piece of html being sent o the screen, I can rewind and reply like a tape recorder.

BTW, I have no hate for React. There are some things I think it does better than any other option. I was a core member of the React Studio team (expired cert on the site but safe to visit for archeological purposes).

adamzwasserman··on Please just try HTMX
At the end of the day, personal preferences play a huge role. All programming is a compromise between tradeoffs.

React has a lot going for it. It's simply that I prefer htmx; it feels cleaner to me.

adamzwasserman··on Please just try HTMX
hx-trigger in the response header would handle that cleanly. Fires an event client-side; one global handler shows the error.

Similar to wvbdmp's approach but without needing the extension

adamzwasserman··on Please just try HTMX
I use nested templates the same way React uses nested components. The key is cascading the context (like props) down the hierarchy. Column order change? One edit in the table template; everything that includes it gets the update.

The "header frontend / body backend" split is a choice, not a requirement. I wouldn't make that choice.

adamzwasserman··on Please just try HTMX
took the words out of my mouth!
adamzwasserman··on Please just try HTMX
my htmx apps have 0 cls. You just have to care enough to do something about it.
adamzwasserman··on Please just try HTMX
Read DATAOS.software for an in depth analysis of bundle sizes and impact on performance.
adamzwasserman··on Please just try HTMX
multicardz is heavy drag-drop ui. totally based on htmx (I still need to get data from a backend, I use htmx to do it for a number of reasons.)
adamzwasserman··on Please just try HTMX
that is why I wrote DATAOS.software. It is a paper/cookbook that answers that question.
adamzwasserman··on Please just try HTMX
Check out DecisionMe.com. 100 percent wizard pattern, htmx based nav and validation.
adamzwasserman··on Please just try HTMX
Not a problem with Jinja (or any server-side templating). Both the table and dropdown render from the same context variable in one template pass. One endpoint, one data fetch, two presentation formats.

The "two endpoints" concern assumes you're fetching fragments independently. If you're composing a full page server-side, the data is already there

adamzwasserman··on Please just try HTMX
I think you misunderstood me. I use htmx where most people would use fetch. I do not just use htmx willy nilly for no reason.

I use pure front end manipulation to set state, then I send the state to the stateless back end with pure functions, and I get amazing performance: www.multicardz.com public test bed, 1M records, round trip usually around 160 ms for anywhere between 1 to 100K hits

adamzwasserman··on Please just try HTMX
Honestly? I never think about it. I've never had to. What did you run into? Curious what the pain point was.
adamzwasserman··on Please just try HTMX
That is what DATAOS.software is all about. It is a manifesto of my proposed best practices somewhat like Hypermedia Systems, but more hands on, more of a cookbook.
adamzwasserman··on Please just try HTMX
The debugging question has a direct answer: when you capture User State from the DOM (via manifest) and send it to pure functions on the backend, you get a perfect event source pattern.

Not only can I can tell you exactly who and what triggered any piece of HTML being sent to screen, I can rewind and replay it like a tape recorder.

The broader philosophical difference: I don't treat "state" as one thing. User State (what the user sees and expects to persist across refresh) lives in the DOM.

Auth state, db cursors, cache: backend concerns. Pure functions on the backend are deterministic; same input, same output, trivially testable.

I have no hate for React; I was a core member of the React Studio team. But for my use cases, this model gives me better debuggability, not worse.

adamzwasserman··on Please just try HTMX
The state encapsulation concern is exactly what DATAOS addresses: dataos.software

The premise is that React's "UI=f(state)" creates a synchronization problem that doesn't need to exist.

If the DOM is the authority on state (not a projection of state held elsewhere), there's nothing to sync. You read state from where it already lives.

I built multicardz on this: 1M+ cards, sub-500ms searches, 100/100 Lighthouse scores.

If you have time to read, I would very much like to hear your thoughts; genuine technical pushback welcome.

adamzwasserman··on Please just try HTMX
Declarative is the way.
adamzwasserman··on Please just try HTMX
Performance
adamzwasserman··on Please just try HTMX
I was able to find architectural patters that work smooth as glass.

Here is what my htmx apps have: - Single-purpose endpoints: Each endpoint returns ONE thing (a card list, a tag cloud, a form fragment) - Optimistic UI: Preferences like font/theme update the DOM immediately; the save is fire-and-forget with no response needed - Simple error handling: Most endpoints either succeed (return HTML) or fail (HTTP error code) - No fragment orchestration: Not returning 3-5 fragments; using hx-swap-oob sparingly

Here is how I update fonts on screen in user prefs: User selects font → JS updates body class immediately → htmx.ajax() saves in background → done

vs. the anti-pattern you're describing:

User submits form → backend validates → returns success fragment OR error fragment OR partial update OR redirect signal → frontend must handle all cases

No language or programming paradigm is perfect. All programming is an exercise in tradeoffs. The mark of a good CTO or architect is that ability to draw out the best of the technology selection and minimize the tradeoffs.

adamzwasserman··on Please just try HTMX
multicards is almost purely client side interactivity. I STILL use htmx for a number of reasons:

- No JSON serialization: HTMX sends form data natively no JSON.stringify() needed - Less JavaScript: Declarative hx-* attributes replace imperative fetch code. in my world declarative always wins. - Automatic headers: HTMX handles X-User-Id and other headers configured globally - Built-in error handling: hx-on::error instead of .catch() chains - Swapping flexibility: Can show success/error feedback via hx-swap without custom JS - Request indicators: Free loading states with hx-indicator - Debugging: HTMX events visible in browser devtools; fetch requires console.log

and most all: performance. multicardz goes like stink. 100/100 lighthouse scores, First Contentful Paint 0.4 s, Largest Contentful Paint 0.5 s, Total Blocking Time 0 ms, Cumulative Layout Shift 0, Speed Index, 0.5 s

still prerelease, but cautiously hope to go general availability by and of year.

adamzwasserman··on Please just try HTMX
DecisionMe is one the apps I created using htmx. I am not the owner of the company, so I cannot comp you, but I can promise in good faith: this is not a toy app.
adamzwasserman··on Please just try HTMX
I have the same problem. I guess we will just have to train our own SLM with a carefully selected (unpolluted) training corpus.
adamzwasserman··on Please just try HTMX
here is the long-promised frontal assault on Big State: dataos.software
adamzwasserman··on Please just try HTMX
Even if you do have complex client-side state: dataos.software
adamzwasserman··on Show HN: MDXport – Browser-Based Markdown to PDF Using Typst and WASM
Just what I needed. I will be trying it out thx
adamzwasserman··on [dead]
nice and clean. FYI the source link is broken.
← PreviousPage 3 of 7Next →