software-design

一篇关于软件设计哲学的工程博客，论述优雅的系统设计往往来自于主动放弃某些需求（如一致性、并发写、低延迟等），并探讨了在业务与技术之间权衡取舍为何困难。

Matt Pocock shares a quote from John Ousterhout's 'A Philosophy of Software Design' about 'tactical tornado' developers who code fast but leave messes for others to clean up, asking if it sounds familiar.

Using analogies from retro games like Tetris, Super Mario, and Pac-Man, this article explains the fundamental difference between composition (has-a) and inheritance (is-a), the fragile base class problem, and why composition should be preferred over inheritance in practice.

A blog essay arguing that plain text remains one of computing's most durable and trustworthy technologies, thanks to its simplicity, portability, human readability, and seamless integration with decades-old Unix tooling like grep, sed, and awk.

Matt Pocock argues that developers should use more abstractions in the AI age, since they constrain agents to good design decisions, improve token efficiency, and make unwinding bad abstractions cheaper when working with AI coding agents.

A commentary on how dysfunctional team culture shows up in product design, arguing that OKR-driven incentives lead teams to ship org-chart bloat rather than build great products—especially in the agentic era when adding features is cheap. Fix culture before fixing the product.

Jim Nielsen writes a response to Marques Brownlee's video essay 'Dear YouTube', arguing that YouTube's new A/B testing feature for video variants undermines the shared community experience of online content and reflects a platform driven by metrics rather than creative conviction.

This essay explores the need for malleable software to restore user agency, contrasting the flexibility of physical environments with the rigidity of mass-produced digital tools and discussing implications for work and creativity.

Whiteboard is an open-source desktop IDE for collaborative software design, integrating with AI agents like Claude Code and Codex to provide visual canvases, semantic diff viewers, and decision logs for enhanced code architecture.

In the era of Vibe Coding, AI makes code generation easy, but software engineering principles like code maintainability and design patterns become more important to address challenges in review, debugging, and refactoring.

The article discusses the risk of AI models inferring missing data in agent systems, potentially leading to unauthorized executions, and proposes separating decision authority from models to ensure only explicitly declared instructions are followed.

The article argues that function arguments are not equivalent to function colors by introducing a change dependency graph criterion, distinguishing how changes propagate in async functions versus normal parameters.

The article argues that simplicity in software design is distinct from smallness, using Unix and Clojure examples to show how simple systems can become complex when changes are made.

This article serves as a postmortem and playbook for building reliable agent harnesses, detailing architectural lessons from omp and the transition to omp² while advocating for design principles that manage complexity effectively.

Yohei Nakajima discusses Tobi Lutke's idea that agent state in AI systems can be simplified to a function of logs, reducing complexity in state management.

The article explores the advantages of DSL-able languages like Kotlin, using a backend web framework sketch called 'kibble' as an example, and contrasts it with annotation-based frameworks like C# ASP.NET MVC to highlight benefits in code readability and design.

The article explores how the social architecture of programming language communities influences the design and quality of standard libraries, comparing approaches in Python, Go, and Rust.

A tweet by @javinpaul recommends 'Clean Code' book and its second edition, highlighting updated insights on software craftsmanship and coding practices across various programming languages.

The article explains that software should be designed to match human cognitive systems, particularly the fast intuition and slow attention processes, for better effectiveness and user experience.

Matt Pocock shares a developer philosophy: rather than writing tests to catch the next occurrence of an error, aim to make that class of error impossible through better design.