Skip to main content

Explore Problems

Pricing Discuss

Fundamentals - Low Level Design

Course Contents

What is Low Level Design? (LLD vs HLD)

Why LLD Matters — The 70% Maintenance Problem

How This Course is Structured

How to Get the Most Out of This Course

Imperative Programming

Procedural Programming

Object-Oriented Programming — The Big Picture

Functional Programming vs OOP — When to Use What

Classes and Objects — Blueprint vs Instance

Constructors — Default, Parameterized, Copy

Encapsulation — Data Hiding Done Right

Abstraction — Hiding Complexity

Inheritance — Code Reuse & Hierarchies

Polymorphism — Compile-Time vs Runtime

Method Overloading vs Overriding

Enums — Type-Safe Constants

Interfaces vs Abstract Classes

Association — Objects That Know Each Other

Aggregation — Has-A with Independent Lifecycle

Composition — Has-A with Dependent Lifecycle

Dependency — Objects That Use Each Other

Composition vs Inheritance — Favor Composition

Generalization vs Specialization

Introduction to UML — Why Visual Modeling Matters

Class Diagrams — Structure of Your System

Use Case Diagrams — Who Does What

Sequence Diagrams — How Objects Interact Over Time

Activity Diagrams — Workflow and Decision Points

State Machine Diagrams — Object Lifecycle States

Reading and Drawing UML — Practical Exercise

Why Design Principles Exist — The Cost of Bad Design

S — Single Responsibility Principle

O — Open/Closed Principle

L — Liskov Substitution Principle

I — Interface Segregation Principle

D — Dependency Inversion Principle

SOLID in Action — Refactoring a Bad Design

DRY — Don't Repeat Yourself

KISS — Keep It Simple, Stupid

YAGNI — You Aren't Gonna Need It

Law of Demeter (Principle of Least Knowledge)

GRASP Principles — General Responsibility Assignment

Composition Over Inheritance

What is Domain Modeling? — From Requirements to Objects

Entities vs Value Objects — Identity and Equality

Aggregates & Aggregate Roots — Consistency Boundaries

Domain Invariants — Rules Your Objects Must Enforce

The Object Discovery Process — Nouns, Verbs, Relationships

Domain Modeling Exercise — E-Commerce Domain

Code Smells — Recognizing Bad Design

Refactoring: God Object → Single Responsibility

Refactoring: Switch-Case → Strategy Pattern

Refactoring: Deep Inheritance → Composition

Refactoring: Tight Coupling → Dependency Injection

Before/After Case Study — Complete Refactoring Walk-through

What Are Design Patterns? — History & Classification

Singleton Pattern

Factory Method Pattern

Abstract Factory Pattern

Builder Pattern

Prototype Pattern

Adapter Pattern — Making Incompatible Interfaces Work

Facade Pattern — Simplifying Complex Subsystems

Decorator Pattern — Adding Behavior Dynamically

Composite Pattern — Tree Structures

Proxy Pattern — Controlling Access

Bridge Pattern — Separating Abstraction from Implementation

Flyweight Pattern — Sharing Common State

When to Use Which Structural Pattern — Decision Guide

Strategy Pattern — Swappable Algorithms

Observer Pattern — Event-Driven Communication

Command Pattern — Encapsulating Actions

State Pattern — Objects that Change Behavior

Template Method Pattern — Algorithm Skeleton

Iterator Pattern — Traversing Collections

Chain of Responsibility — Passing the Request

Mediator Pattern — Centralizing Communication

Memento Pattern — Undo/Snapshot

Visitor Pattern — Adding Operations Without Changing Classes

Null Object Pattern — Eliminating Null Checks

When to Use Which Behavioral Pattern — Decision Guide

What is Software Architecture? — Monolith, Layered, Clean

Layered Architecture — Presentation, Service, Repository

Dependency Injection — Constructor, Setter, Interface

DI Containers & Inversion of Control

Module Separation — Package Structure & Access Control

Introduction to Concurrency — Why It Matters for LLD

Concurrency vs Parallelism

Processes vs Threads — Lifecycle and States

Race Conditions and Critical Sections

Synchronization Primitives — Mutex, Semaphore, Condition Variable

Deadlock, Livelock, and Starvation

Locks — Reentrant, Try-Lock, Compare-and-Swap (CAS)

Thread Safety — Immutability, ThreadLocal, Atomic Operations

Producer-Consumer Pattern

Reader-Writer Pattern

Thread Pool Pattern

Signaling Pattern

Active Object Pattern

How to Approach Any LLD Problem — The 4-Step Framework

Step 1: Clarify Requirements & Define Scope

Step 2: Identify Core Objects and Relationships

Step 3: Draw UML Diagrams (Class, Use Case, Sequence)

Step 4: Implement with Patterns & Principles

When to Use Which Creational Pattern — Decision Tree

When to Use Which Structural Pattern — Decision Tree

When to Use Which Behavioral Pattern — Decision Tree

Complete Design Patterns Quick Reference

Top 10 Tips for LLD Interviews

Common Mistakes and How to Avoid Them

Practice Plan — 30, 60, 90 Day Roadmaps

Course Conclusion & Next Steps

Refactoring: God Object → Single Responsibility

Refactoring: God Object → Single Responsibility on CodePeet.

Loading...

Loading content...