An introduction to finite state machines in software, explaining their structure and demonstrating a simple implementation with a JavaScript light switch example.
Explores five different approaches to implementing polymorphism in Django models, a common challenge in Django ORM design.
A software architecture article advocating for organizing code by business features instead of technical layers to improve cohesion and maintainability.
A guide to improving Swift code maintainability and testability by separating decision logic from action logic using the type system.
Explores the benefits of Test-Driven Development (TDD), including preventing false positives, improving design, and providing fast feedback.
A beginner-friendly explanation of dependency injection using a car analogy, contrasting it with inheritance and promoting composition.
Explores the design and use of a custom error handling package in the Upspin project, with lessons for Go programming.
A guide to building a reusable JavaScript validator service to clean up data validation logic and adhere to DRY and SRP principles.
Explains how to implement the Lazy Command Pattern in ASP.NET Core MVC to reduce controller bloat and improve code organization.
Explores the mindset shift from writing code to designing systems, focusing on user impact and strategic technology choices.
A technical guide on designing robust Django models for a bank account system, covering constraints, logging, and best practices.
Explains the importance of making class dependencies explicit in software design to reduce surprises and improve code maintainability.
A programming article advocating for structuring code like a newspaper, with the most important information at the top for better readability.
Explores how to effectively handle software architecture within agile projects, based on a talk by Molly Dishman and Martin Fowler.
Explains four key programming principles (KISS, DRY, YAGNI, SOLID) for building sustainable and maintainable mission-critical software applications.
A look back at Node.js's growth in 2014 and an introduction to a new weekly series on JavaScript design patterns, starting with the Factory pattern.
Explains the Factory design pattern in Node.js for simplifying and centralizing complex object creation in JavaScript applications.
Analyzes the debate between using single vs. multiple return statements in methods, focusing on readability and modern coding practices.
Explores Java's Optional type as a tool for writing intention-revealing code and avoiding null references, part of a detailed series.
A summary of Martin Fowler's talk on refactoring workflows, covering the refactoring mindset, the 'two hats' metaphor, and reasons to refactor.
