Kotlin — Design Patterns Masterclass

★ A hand-authored, chapter-by-chapter course — not a drill pack. Starts with OOP foundations and the five SOLID principles, then walks the full Gang-of-Four catalogue (Singleton through Visitor + Flyweight) re-told through idiomatic Kotlin (`object`, `data class.copy()`, sealed-class `when`, function-type Strategy), and finishes with a Ride-Sharing capstone where you compose four patterns into one working back-end. Every lesson ships explanatory prose, captioned canonical examples, a runnable practice challenge with stdin/stdout tests, AND a hand-authored animated walkthrough (actors, events, narration) so you SEE the shape — not just read about it. 36 lessons · 43 challenges · 85 test cases · 158 frames · server-side Kotlin 1.8.20.

59 challenges79 topics

How it works1Pick a challenge2Read the requirements3Code in a full IDE4Run the tests

59 challenges

OOP: classes, interfaces, inheritance, polymorphism

Access modifiers (public / private / protected / internal)

UML class diagrams (just enough to read pattern docs)

SOLID principles — the design quality scaffold

Single Responsibility Principle (SRP)

Open/Closed Principle (OCP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Dependency Inversion Principle (DIP)

What are design patterns?

Types of design patterns

Singleton · Singleton: shared counter

Singleton · Singleton: app config

Factory Method · Factory: shape codes

Factory Method · Application: document creation

Abstract Factory

Builder

Lazy initialisation

Prototype

Adapter

Bridge

Facade

Decorator

Composite · Composite: folder size

Composite · Application: restaurant menu

Proxy

Flyweight

Observer · Observer: temperature alerts

Observer · Application: stock price ticker

Chain of Responsibility

Command · Command: editor with undo

Command · Application: TV remote control

Strategy · Strategy: tax modes

Strategy · Application: FlexiText formatter

State · State: traffic light

State · Application: media player

Visitor

Mediator

Memento

Iterator

Template Method

Null Object — make absence a first-class behaviour

Specification — composable business rules

Repository — the data-access seam every backend grows

Dependency Injection — wire collaborators from the outside

Object Pool — reuse expensive instances instead of recreating

Delegation with `by` — composition the language does for you

Interpreter — a sealed-class grammar you can evaluate

Result / Railway — model failure as a value, not an exception

Event Bus — decoupled publish/subscribe across the app

Pipeline — compose small functions into a data flow

Multiton — one instance *per key*, not one globally

Property delegation — observable & vetoable properties

Memoization — cache a pure function's results

Type-safe DSL builder — builders with lambda receivers

Circuit Breaker — stop hammering a failing dependency

Step builder — enforce build order with interface stages

Capstone — Ride-Sharing app (multiple patterns composed)

Wrap-up & next steps