Bilingual

A sufficiently comprehensive spec is not (necessarily) code
15 hours ago
- A specification is an abstraction representing a set of possible implementations, not code itself.
- A spec is sufficient if any reasonable implementation within it satisfies the specifier, even if not fully comprehensive.
- Programmers are still needed to encode specs in formal languages like test suites, which remain distinct from code.
- LLM non-determinism and language vagueness mean specs may produce inconsistent results, reinforcing the distinction between spec and code.
- Even low-level programs (e.g., C or machine code) can be seen as specs due to varying implementations.
Entropic Thoughts
15 hours ago
- Abstractions must be carefully designed, anticipating all purposes while forgetting none, as per Richard Gabriel's quote.
- MVC and similar layered architectures separate by technical boundaries (e.g., presentation, business, persistence) rather than logical concerns, leading to integration of concerns.
- Proper separation of concerns ensures that changes to requirements have a small blast radius; features in MVC affect all layers.
- David Parnas' insight: business domain concepts change less than technical concepts, so modules should align with business fundamentals.
- Extension and contraction (adding/removing features) is easier when modules are drawn along business domain boundaries, not technical layers.
- An 'onion architecture' or inside-out design with stable core business fundamentals at lower layers reduces the need to 'move quickly across layers'.
- Each layer should act as a virtual machine for the layer above, with stable definitions at bottom, as suggested by Dijkstra.
- Locality of behaviour and onion architecture promote good modularity, contrasting with MVC's 50-year-old but still prevalent approach.
What Are the React Team Principles? — overreacted
15 hours ago
- Design APIs by starting with the desired user experience and working backward to the abstraction, prioritizing UI over API.
- Accept internal complexity in React to simplify product development, absorbing complexity to prevent it from bleeding into product code.
- Allow hacks through escape hatches, then observe and eventually provide idiomatic solutions for those that improve user experience.
- Enable local reasoning so developers can make changes safely with only local code knowledge, avoiding global dependencies.
- Favor a single gradual path from simple to complex features over a forked approach that requires rewrites.
- Contain damage from performance or quality issues, ensuring developers and users only pay for features they use or interact with.
- Trust theory to avoid local maxima, investing in approaches that are fundamentally sound even if they take years to realize.
A Chain Reaction — overreacted
15 hours ago
- Web standards like HTML tags allow developers to use conceptual names (e.g., `<p>`, `<i>`) without knowing the underlying browser implementation details.
- Naming concepts enables abstraction, letting developers build complex systems by layering behaviors, such as defining custom components like `Greeting`.
- Custom components (e.g., `<Greeting>`) must be translated into browser-understood tags via functions that substitute them with their definitions (e.g., an `ExpandableGreeting` function outputs `<details>` with inner JSX).
- The translation process recursively resolves nested custom components until only built-in tags remain, akin to a chain reaction dissolving user-defined concepts into browser-ready code.
- Implementing this translation involves handling both custom functions and built-in tags, ensuring children of built-in tags are also processed recursively.
- The translation can occur on either the server or client side, but must complete before the browser renders the final output.
AI Is a Bad Tool
15 days ago
- AI can be useful as a data distiller, condensing information retrieval and refinement steps that were previously manual.
- Using AI to generate code is inefficient; it often produces unverified, opaque outputs that lack proper abstraction and increase repetition.
- AI's opacity makes 'prompt engineering' questionable, as manipulating a black-box system without understanding its source code is unstable and unreliable.
- AI exposes a lack of proper abstraction in software development, revealing that many programming tasks could be automated by better tools or frameworks.
- The fear of AI making humans irrelevant stems from its ability to handle trivial, unabstracted work, highlighting that many software jobs were already inefficient.
- Dealing with AI's impact may require focusing on passion-driven work, full understanding, and proper abstraction to avoid reliance on AI for non-problems.

abstraction

A sufficiently comprehensive spec is not (necessarily) code

Entropic Thoughts

What Are the React Team Principles? — overreacted

A Chain Reaction — overreacted

AI Is a Bad Tool