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.
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.
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 software cohesion as a metric for refactoring, with a C# example showing how to split a low-cohesion class.
A guide to building a simple Dependency Injection container in .NET, explaining IoC and DI concepts with code examples.
Explains the key differences between abstraction and encapsulation, two fundamental object-oriented programming concepts.
Explores architect Christopher Alexander's design philosophy and its profound, often misunderstood, application to software development and programming patterns.
A developer envisions a perfect digital note-taking app with infinite grids, multi-format objects, and seamless input/export, hoping to inspire its creation.
Explores the pitfalls of using public const in C#, explaining compile-time replacement and versioning issues, and suggests using static readonly instead.
An analysis of current challenges and future trends in micro-frontends architecture, covering client, server, and edge implementations.
Explores why successful tech products often prioritize familiar user experiences over unique, novel features, using examples like Astro and Supabase.
