Explores the Data-Oriented Programming principle of separating operations from data, using Java records as an example.
Explores immutability and transparency in data modeling using Java records, part of a series on Data-Oriented Programming v1.1.
Explains tagged singletons in dependency injection, allowing multiple singleton instances of the same class distinguished by tags for different contexts.
Explores Data-Oriented Programming in Java, updating Brian Goetz's guidelines using modern features like records, sealed types, and pattern matching.
Argues for using multiple React component compositions over inline conditionals for better code maintainability and understandability.
Explores two types of composition in programming: function (nesting) composition and object (merging) composition, with practical examples.
Explores the 'Fewest Elements' rule in software design, advocating for removing unnecessary code like unreachable lines, comments, and unused abstractions.
Explains the 'No Duplication' rule in software design, detailing its benefits for maintainability and enabling change.
Explores the 'Reveals Intention' rule from Kent Beck's Four Rules of Simple Design, focusing on writing clear, readable code.
Explains evolutionary design in software development as a middle path between over- and under-design, emphasizing simplicity and refactoring.
A summary of John Ousterhout's book on managing software complexity through decomposition, encapsulation, and incremental design.
Explores eigensolutions and composability in creator tools to combat overfitting and improve generalization across diverse use cases.
A Google engineer's 2009 talk on the importance of simplicity in software design, contrasting Google's simple homepage with its complex internal systems.
A software engineer draws parallels between spacecraft design principles and software engineering, emphasizing data-driven decisions and balanced system design.
A guide to identifying and fixing YAP (Yet Another Prop) Syndrome in React components by using composition over excessive props.
Explores using .NET Minimal API endpoints as the application layer, advocating for the REPR pattern to simplify project structure and reduce unnecessary layers.
Analyzes why the registration pattern in config systems fails to scale, highlighting import-time costs and proposing alternatives.
Explores the balance between subclassing and composition in Python, arguing for a pragmatic approach to object-oriented design.
Explains why deep code nesting is problematic and demonstrates refactoring techniques like extraction and inversion to reduce complexity in C#.
Explains how to implement class-like abstractions in Clojure using namespaces, specs, and functions, without traditional OOP constructs.
