The Configuration Provider: Roles and Responsibilities
A Configuration Provider hides the source and returns validated, typed settings. Useful exceptions and composed settings providers keep configuration rules in one place.
Operationalized guidance
Programming With Intent
Four pillars covering how code is structured, written, verified, and how it fails. Each rule is specific enough to apply the same way twice.
Programming With Intent began as a long-running video series. The chapters below carry that material as text, with worked examples in Python and C#.
Guidance is written to be applied rather than admired. Most rules exist because a specific class of defect kept recurring, and the chapter says which one.
Recurring phrases run through the chapters, and their canonical meanings live in the Aphorism Glossary. Each definition lists the chapters that invoke it.
One of the four pillars sits in the top-level navigation in its own right. Verification with Intent isAcceptance Testing, promoted because functional acceptance testing at the boundary is the practice that earns confidence to ship. Its chapters live there rather than being copied here.
The four pillars
Architecture with Intent
Layers, boundaries, and where responsibility belongs.
Programming with Intent
Classes, methods, naming, and the shape of everyday code.
Verification with Intent
Functional acceptance testing at the boundary. Proving the thing does what it claims.
Programming to Exceptions
Failure as a designed path rather than an afterthought.
Design patterns
Factories, configuration and service boundaries explained through their responsibilities and worked examples. Browse all design pattern articles.
Factory Method Pattern: The Most Beautiful Pattern We Lost
Factory Method lets consumer subclasses choose dependencies through an overridable creation hook. C# examples show its two class families and distinguish it from a separate Factory.
Factory Pattern: The Enabler of Polymorphism
A Factory selects and constructs a concrete descendant while callers program to an interface through the base class's public contract. C# thumbnailers show selection and polymorphic dispatch.
The Gateway Design Pattern: Roles and Responsibilities
A Gateway presents business operations, translates service models and transforms failures into domain exceptions, keeping external service details behind one boundary.
All topics
21 topics. Chapter numbers are deliberately absent, because the two language families number their chapters independently.
- Architecture Layers
- Class Design
- Method Design
- Naming Conventions
- Configuration Provider
- Gateway Design Pattern
- Programming to Exceptions series
Method contracts, exception design, and logging in one shared reading sequence.
- Factory Pattern
- Factory Method Pattern
- Type Annotations
- LINQ Query Semantics
- Messaging Patterns
- Anti-Patterns
- Encapsulating Third-Party Libraries
- Boundary Validation
- Code Correctness and Runtime Safety
- Intentional Model Design
- Adapter Pattern
- Decorator Pattern
Marked language-independent on the assumption this is the GoF pattern. If the chapter is about Python's @ decorator syntax, scope should be 'python'.
- Python Language Style
- Data Manager Design
Examples are C# today.