A critical analysis of the Instability-Abstractness-Relationship, a software design quality metric for measuring package maintainability.
A developer's critique of inheritance misuse in OOP, comparing abstract classes vs. interfaces and advocating for better design patterns.
Explains how to use protocol-oriented programming in Swift to design flexible applications by focusing on what entities can do rather than what they are.
Simon Tatham defines 'symbiosisware' as software written solely for the developer's own use, exploring its unique characteristics and trade-offs.
Explores the rationale behind updating Data-Oriented Programming principles to version 1.1 for Java, discussing improvements and shortcomings.
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.
