Independent notes · Warsaw
Ideas worth carrying into the work.
Essays about software, systems, and the quiet decisions that shape what we make.
From the archive
Functions need spaces
Snake case makes function names readable verb phrases by writing word boundaries explicitly instead of asking capitalization to impersonate punctuation.
Leave the scar visible
Workarounds need angry comments, ugly names, and explicit exit conditions so later maintainers recognize debt instead of inheriting it as design.
The locker at the corner
Poland’s parcel-locker ecosystem beats Amazon’s captive delivery model by separating where you buy from where and when you receive.
Poland in cat ears
The Polish catgirl-programmer stereotype comes from overlapping internet visibilities rather than evidence that Poland produces unusually many gender-nonconforming developers.
Types considered harmful
TypeScript becomes dangerous when you silence honest absence with plausible defaults that satisfy the shape and corrupt the meaning.
The guild and the commons
Programming-language communities place the cost of learning either on entrants or on stewards, and each choice can harden into a status system.
The route changes the road
SUMO confronted the feedback between route choice and congestion in its earliest design, then made routing and simulation correct each other through an explicit iterative toolchain.
Advice after the warning
Accessibility guidance becomes useful when reviewers separate requirements from design judgment and leave developers with a next action instead of a vague veto.
The branch predictor cannot force your thunk
Compiling a lazy functional language to WebAssembly works best when demand analysis removes thunks before lowering; branch hints can only annotate the predictable control flow left behind.
The round-trip test
Bun's Rust rewrite changed the language, implementation, review process, and security budget at once; an LLM port back to Zig would reveal which improvement came from where.
The cabinet of impossible machines
Five languages from one archived esolang repository show what happens when functions, bits, sets, a self-modifying machine description, or Peano arithmetic is forced to carry an entire program.
The future has plaque
Technological progress keeps expanding what we can do, but living systems still demand the same repetitive care every day, because maintenance is a permanent condition of the body rather than a bug waiting to be patched.
The runtime surplus
WebAssembly has an engine surplus because runtimes can compete independently while useful contracts, packages, debugging, and deployment require ecosystem agreement.
Polish does not compile
Polish makes a terrible programming language because too much of each sentence lives outside the text, in the speaker and the conversation.
Functional before runtime
Zig's comptime can compose functions and types into specialized programs while the runtime keeps allocation and control flow in plain sight.
Grain meets you halfway
Trying Grain convinced me that functional language design becomes approachable when algebraic data types feel ordinary, mutation is explicit, and WebAssembly stays a deployment detail.
Thirty-two bytes at once
In stable Rust, a practical SIMD workflow keeps the scalar loop around as the oracle for one fenced AVX2 kernel and lets the benchmark decide whether the kernel survives.
Straight to the module
Hand-written WebAssembly is a pleasure while the whole contract fits on one screen, and misery the moment it needs an ABI.
Fail where the fault lives
Fail-fast is a debugging rule about exposing faults near their cause; reliable systems contain the damage there and make recovery explicit rather than crashing broadly.
The architecture diagram shrank
Cloudflare keeps folding routing, state, durable work, browsers, containers, and AI into one programmable surface, and that compression is the real advantage.
Who the button hides
A button that promises dinner or a ride compresses another person's time and judgment into a single clickable verb.
The review needs a suspect
An LLM can catch bugs in its own patch because the first draft gives the review pass concrete evidence to inspect.
“Make no mistakes” is not a method
Telling people to make no mistakes hides the evidence a reliable system runs on; a process built to catch and repair a mistake gets closer to zero than the demand ever does.
The missing bridge
A nonsense sentence about bananas and hats shows how little the material conditional has to do with the connection English hears in the word if.
Typeclasses with the grain
Functional programming in TypeScript becomes elegant when Haskell's laws are translated through native JavaScript shapes instead of copied as foreign syntax.
The ternary hangover
AI writes nested ternaries without feeling their weight, leaving the reviewer to reconstruct control flow from punctuation.
Make evaluation visible
Haskell performance improves when you measure demand, allocation, and residency, then make evaluation and representation explicit only at proven hot paths.
Tokens for yesterday
AI spends much of its intelligence preserving documents and workflows that only exist because human coordination used to be slow.
The forty-second first draft
Disclosure Day shows what happens when 42 drafts of revision polish a screenplay without anyone reopening its premise.
The AI sheen
AI-generated images remain hard to accept because their default polish has become a visible shorthand for cheap, unconsidered work.
Beyond recursion
Recursion describes repeated structure well, but production traversal needs explicit work once depth, cycles, budgets, or cancellation matter.
Comptime behind glass
Zig's comptime is useful, but a public API generated where the editor can't see it makes the feature harder to trust.
The building block economy
Agents make integration cheap enough that small, dependable capabilities can become products in their own right.
The functional inheritance
Mainstream languages quietly inherited functional programming, and the next step is making mutation and effects visible in the types.
The compiler on the wide machine
A compiler can run on the GPU only if the language it compiles breaks the build into many small independent jobs.
Building for the second reading
A note on making software that grows clearer when people return to it.
The shape of a code block
How this journal renders code: a hand-rolled tokenizer on the server, and a copy button's worth of client JavaScript.
Browse by tag
craft14
- Print the path
- Leave the scar visible
- Poland in cat ears
- The guild and the commons
- Advice after the warning
- The future has plaque
- Polish does not compile
- Who the button hides
- “Make no mistakes” is not a method
- The missing bridge
- The forty-second first draft
- The AI sheen
- Building for the second reading
- The shape of a code block
software30
- Print the path
- Functions need spaces
- Leave the scar visible
- The locker at the corner
- Poland in cat ears
- Types considered harmful
- The guild and the commons
- The route changes the road
- The branch predictor cannot force your thunk
- The round-trip test
- The cabinet of impossible machines
- The runtime surplus
- Polish does not compile
- Functional before runtime
- Grain meets you halfway
- Thirty-two bytes at once
- Straight to the module
- Fail where the fault lives
- The architecture diagram shrank
- The review needs a suspect
- Typeclasses with the grain
- The ternary hangover
- Make evaluation visible
- Tokens for yesterday
- Beyond recursion
- Comptime behind glass
- The building block economy
- The functional inheritance
- The compiler on the wide machine
- Building for the second reading