Design Patterns: Real World Systems from Theory to Code

Explore how encapsulation protects a class's internal state in object oriented programming, using a private balance and get/set methods to control access to account objects.

Set up a TypeScript project and implement an account class with a private balance. Use get balance and set balance methods to validate the user and demonstrate encapsulation.

Explore inheritance in object oriented programming by letting a child reuse an animal class's walk, speak, and eat via cat and kitten.

Explore practical inheritance in TypeScript and object oriented programming by building an animal class with walk, speak, and eat, then extend it with cat and kitten.

Explore polymorphism in object oriented programming through inheritance, showing how animal, cat, kitten, and cow override eat and speak to express many forms, including overloading.

Explore polymorphism in TypeScript by overriding eat methods in cat and kitten, and using super to call parent methods, illustrating control flow from kitten to cat to animal with outputs.

Learn how abstraction hides complex logic behind interfaces and abstract classes, exposing only what is necessary in payment processing with PayPal or Stripe.

this lecture explains the single responsibility principle: a class should have one reason to change, split into dedicated invoice repository, invoice printer, and invoice mailer.

Explore how the open/closed principle makes software entities open for extension yet closed for modification by refactoring with a discount strategy interface and multiple discount classes (student, senior, future managers).

Explore the Liskov substitution principle, showing how substituting a base type with a subtype must not break behavior, illustrated by petrol engine in cars vs Tesla and notifier implementations.

Explore the interface segregation principle by separating interfaces so clients depend only on needed methods, using a multi-device remote analogy and a printer example with print, scan, and fax.

apply the dependency inversion principle by letting high level modules depend on an abstraction, enabling the main class to log via a logger abstraction with file, API, or data loggers.

Explore the singleton design pattern, a creational pattern that guarantees one instance and a single globally accessible database connection via a private constructor and a getinstance method.

Practice the singleton design pattern through a practical TypeScript example that creates a single DB connection and reuses it across get users and get product details.

The factory method pattern defines an interface for creating objects, letting subclasses choose the object type in a payment gateway context with credit card, UPI, and PayPal.

Explore the factory method design pattern in TypeScript by building a payment system with a payment interface, credit card and UPI payments, and gateway classes that instantiate and process payments.

Explore the abstract factory design pattern, illustrating a report web page that downloads as pdf, excel, html, or json, with an abstraction that creates and renders the correct document.

Explore the practical abstract factory pattern in TypeScript by building header, content, and footer interfaces and PDF, Excel, and HTML exporters that render downloadable documents via a runtime switch.

Explore the builder design pattern theory, constructing a social media post object step by step with a chain of methods, using optional parts like video, image, or text.

Learn how to implement the builder design pattern in TypeScript to compose a social media post. Include optional text, image URL, video URL, and polls, then build and publish.

Explore the prototype design pattern, a creational pattern, that clones existing objects from a predefined template to quickly build ecommerce pages and customize headers and content.

Implement the prototype design pattern in TypeScript by cloning a social media post template to create multiple posts with shared content, hashtags, media, and schedule times.

Understand the adapter design pattern, which lets a payment gateway communicate with UPI, credit card, and PayPal by adapting their make payment and initiate payment interfaces, enabling scalable integration.

Learn the adapter design pattern by implementing a payment gateway that connects UPI and credit card payments through adapters and a common payment processor interface.

Explore how the bridge design pattern separates abstraction from implementation, bridging two hierarchies to enable platform-specific rendering for a generic user interface component library.

Explore the bridge design pattern with a two-layer architecture, where an abstraction theme delegates to a renderer in React and React Native to apply dark and light themes.

Treat leaf and composite nodes uniformly with the composite design pattern, enabling tree-like structures such as files and folders or cart items, with a single query for size or price.

Demonstrate the composite design pattern in a TypeScript example by modeling leaf and composite nodes that share a cart item interface with get name and get price, summing item prices.

Explore the decorator design pattern as a structural method to dynamically add behavior to objects without changing their code, with NestJS decorators enforcing token validation and role-based access.

Explore the decorator design pattern in action: build a text component with a base class and decorators, bold, underline, and italic, composed via render methods to modify output.

Learn how the facade design pattern provides a simplified interface to a complex subsystem, enabling one button control for IoT devices and a dashboard API gateway in microservice architectures.

Learn how the facade design pattern simplifies complex microservice interactions by building an API gateway facade that orchestrates user, order, inventory, and payment services to deliver a dashboard.

Learn how the flyweight design pattern reduces memory use by reusing intrinsic data—image, title, and description—while extrinsic data like price and stock varies per user.

Create and reuse a flyweight for product info by caching intrinsic state in a product factory while rendering extrinsic state like price and stock per display.

Explore the proxy design pattern as a smart middleman that controls access to expensive or remote objects, using a CDN to cache content with TTL.

Explore the proxy design pattern with a TypeScript simulation: origin server, a CDN proxy with a 10-second TTL, and a cache that fetches products on cache expiry.

Explore the chain of responsibility design pattern by passing a series of handlers—metadata enrichment, local storage logger, remote logger, and security audit logger—where each may process or forward for logging.

Build a chain of responsibility in TypeScript with five log handlers: metadata enricher, level filter, local storage, remote logger, and security audit logger, to demonstrate event dispatch through the chain.

Explore how the command design pattern decouples the sender from the receiver by encapsulating requests as objects, using an invoker to trigger turn on or off.

Explore the command design pattern through a practical TypeScript example that encapsulates actions as turn on and turn off commands, wired via a remote invoker to a light bulb receiver.

Explore the iterator design pattern, which provides sequential access to a collection without revealing its underlying representation, illustrated by a library librarian and a cart iterator with a discount engine.

Apply the iterator design pattern to a shopping cart and the discount engine. See how items pass with hasnext and next, enabling 10% off electronics over 1000 and bulk discounts.

The observer design pattern defines a one-to-many relationship where a subject's state changes notify and update observers automatically, as a weather station updates temperature display, fan, and ACs.

Apply the observer design pattern in code with a weather station that notifies temperature display and fan observers through update, demonstrating subscription and responsive actions to temperature changes.

Explore the mediator design pattern, a centralized communication model where a mediator routes messages between objects, illustrated by chat rooms, and contrasted with the observer pattern.

Explore the mediator design pattern through building a chat room system that uses a chat mediator to register users, route messages, and broadcast to all peers except the sender.

Explore the state design pattern, where an object's behavior changes with its internal state by delegating to state-specific classes, demonstrated with a media player's play, pause, and stop.

Explore the state design pattern by implementing a media player in TypeScript with play, pause, and stop methods across playing, paused, and stopped states, showcasing state-driven behavior.

Explore the strategy design pattern, which defines a family of interchangeable algorithms encapsulated to vary independently from clients, illustrated by logistics options like DTDC, FedEx, and UPS.

This lecture demonstrates the strategy design pattern in code by implementing a shipping calculator with three strategies—Fedex, UPS, and DTDC—selectable at runtime to compute cost based on weight and distance.

Explain the template method design pattern as a behavioral pattern that defines a base class algorithm skeleton and defers steps to subclass implementations in a data load, process, save pipeline.

Implement a data processing pipeline with the template method design pattern in TypeScript. Extend an abstract data processor to load, parse, and save data with json and xml processors.

Celebrate your journey through software design patterns as you complete this course, and thank you for joining; your dedication and enthusiasm made the learning a joy.