TypeScript uses structural subtyping, so anything whose shape matches can be passed straight through without an explicit implements. This chapter looks at where the need for a converter in between still remains.
An object with many optional arguments can be assembled from a literal. An ordering constraint such as "you cannot build until this value is set" is something TypeScript's types can express.
The structure of handing a request along step by step is widely used as middleware in Node.js. This chapter goes as far as building context up through types.
In this chapter, you learn the basics of how to write classes in TypeScript.
Where Part 1 comes together. Fills in the open-closed, Liskov substitution, and interface segregation principles, then revisits everything so far through cohesion and coupling.
When you handle a tree, a recursive discriminated union can stand in for a class hierarchy built on a shared interface. The subject here is a file system.
Despite the shared name, GoF's Decorator pattern and TypeScript's Decorators syntax are different concepts. This chapter separates the two, then compares the pattern with composition through higher-order functions.
This chapter presents Strategy, Singleton, Observer, and Abstract Factory from the problems each was designed to solve. It covers commonly conflated pairs like Strategy vs. State, Observer vs. polling, and Abstract Factory vs. Factory Method.
Covers the danger of public properties, the tell-don't-ask principle, and how to decide whether you need getters and setters.
In TypeScript, pulling creation logic out usually needs nothing more than a plain function and a union of literal types. Abstract Factory only earns its place when a constraint ties several related products together.
Covers is-a and has-a relationships, and why composition is preferred over inheritance.
In this chapter, you learn about class inheritance and interfaces in TypeScript.
Covers designing against contracts with interfaces, and the idea behind the dependency inversion principle.
Chapter 1 of the PHP Class Design Guide. Through real examples of god classes and code that resists change, it shows what class design is for and lays out the shape of the whole series.
The abstraction of iteration is in the language specification as Symbol.iterator and generators. This chapter checks whether any reason remains to write an Iterator class of your own.
Before you build a notification mechanism of your own, there are standard tools: EventTarget and AbortSignal. This chapter looks at how far the standard gets you, unsubscription included.
Rereads value objects, aggregates, and domain services from the side of object-oriented principles. It maps which pattern encapsulation, composition, and polymorphism each show up in, and what the pattern adds on top. The principles themselves are left to the PHP Class Design Guide.
A 14-chapter guide that takes class design in PHP from first principles to practice. It runs from framework-independent design principles (encapsulation, single responsibility, inheritance versus composition, interfaces, SOLID) through to model and service class design in Laravel.
The basic syntax of classes in PHP. Covers properties, methods, constructors, visibility modifiers, readonly, constructor promotion, and enum.
JavaScript has a built-in object called Proxy, and it is not the same thing as GoF's Proxy pattern. This chapter covers both, using lazy loading and access logging as its subjects.
Repository comes from PoEAA, not GoF. To avoid overlapping with the existing articles, this chapter narrows to how TypeScript's types express this boundary.
An ES module is evaluated only once as long as it resolves to the same URL, so you get a single instance without writing a Singleton class. This chapter maps how far that guarantee reaches and when you still need another approach.
Instead of a class per state, representing states with a discriminated union lets the type forbid operations the current state cannot accept. The subject here is a vending machine.
If all you do is swap behavior, passing a function is enough. What still makes you want to bundle things into an object is a strategy that carries several methods or state.
A short take on the eight patterns that got no chapter of their own, plus every judgment in the series collected into one table. It also lays out the steps for deciding whether to use a pattern.
Inheriting from an abstract class is not the only way to fix the skeleton of a procedure and swap out one part of it. This chapter sorts out how that differs from taking hook functions.
The single responsibility principle and the idea of keeping classes small. Covers the signs of a god class and a worked example of splitting responsibilities.
A 16-chapter guide that rereads the 23 GoF patterns in modern TypeScript. Each chapter judges whether language features can replace the pattern, and lays out the conditions under which writing it as a class still pays off.
With an exhaustiveness check built from a discriminated union and never, the type prevents forgotten cases without assembling Visitor's class hierarchy. The subject here is a syntax tree.