Mock LLD Interview: Live Class Diagram Session

Overview

Welcome to the thirty-first lecture of Section 6: Low-Level System Design in the Official CTO journey! Mastering a low-level design (LLD) interview is a critical skill for FAANG interviews, requiring you to design systems and create class diagrams live. In this 25-minute lesson, we conduct a mock LLD interview focusing on a live class diagram session for a library management system, a common interview problem. We’ll cover how to approach LLD interviews, design a system, and draw a UML class diagram. Whether preparing for a FAANG interview or honing your design skills, this lecture equips you to excel in LLD interviews. Let’s dive in and continue the journey to becoming a better engineer!

Inspired by Clean Architecture, Design Patterns, and Refactoring, this lesson provides a practical Java example with a UML diagram and practice exercises, aligning with OOP principles and industry standards.

Learning Objectives

• Understand LLD interview strategies and how to create class diagrams live.
• Learn to design a library management system with classes, relationships, and functionality in Java.
• Apply OOP principles (Section 2, Lecture 1), design patterns (Section 3), design principles (Section 4), and HLD concepts (Section 5) to LLD interviews.
• Write clean, modular Java code (Section 9).

Why Mock LLD Interviews Matter

LLD interviews are a staple in FAANG technical interviews, testing your ability to design systems, articulate trade-offs, and create clear class diagrams under pressure. Drawing from my experience mentoring engineers, I’ve helped design systems like library management to ensure clarity and scalability. This lecture prepares you to tackle LLD interviews confidently, showcasing your design and communication skills.

In software engineering, LLD interviews help you:

• Demonstrate Design Skills: Model systems with clear class relationships.
• Articulate Solutions: Explain design choices and trade-offs.
• Prepare for FAANG: Practice real-world interview scenarios.
• Teach Effectively: Share practical LLD strategies.

Key Concepts

1. LLD Interview Approach

• Understand the Problem: Clarify requirements (e.g., library management: books, users, borrowing).
• Identify Entities: Define key classes (e.g., Book, User, Library).
• Design Relationships: Use UML to model associations, inheritance, and dependencies.
• Implement Functionality: Focus on core operations (e.g., borrow, return books).
• Discuss Trade-offs: Explain design choices (e.g., in-memory vs. database).

2. Library Management System Components

• Entities: Books (ID, title), Users (ID, name), Library (manages books and users).
• Functionality:
  • Add/remove books and users.
  • Borrow/return books.
  • Query book availability.
• Edge Cases: Unavailable books, duplicate IDs, invalid users.

3. Design Patterns

• Singleton Pattern (Section 3, Lecture 1): For library instance.
• Observer Pattern (Section 3, Lecture 6): For notifying book availability changes.
• Strategy Pattern (Section 3, Lecture 4): For borrowing policies (extensible).

4. Relation to Previous Sections

• OOP (Section 2, Lecture 1): Encapsulation and polymorphism for book and user classes.
• Design Patterns (Section 3): Singleton, Observer, and Strategy patterns.
• Design Principles (Section 4): SoC (Lecture 11) separates book and library logic; KISS (Lecture 8) simplifies design.
• HLD (Section 5):
  • Library Management (Lecture 11): Revisits the same system for deeper LLD focus.
  • LLD Intro (Lecture 1): Builds on class design.
  • Database Design (Lecture 2): Persisting library data.
  • API Design (Lecture 3): Exposing library controls.
  • Concurrency Handling (Lecture 4): Thread-safe borrowing.
  • Error Handling (Lecture 5): Handling invalid inputs.
  • Parking Lot (Lecture 6): Similar resource management.
  • Elevator System (Lecture 7): Similar state-driven design.
  • Vending Machine (Lecture 8): Similar operation logic.
  • ATM Machine (Lecture 9): Similar transactional design.
  • Restaurant Management (Lecture 10): Similar resource tracking.
  • Chess Game (Lecture 12): Similar rule enforcement.
  • Tic-Tac-Toe (Lecture 13): Similar logic.
  • Snake and Ladder (Lecture 14): Similar mechanics.
  • Deck of Cards (Lecture 15): Similar entity management.
  • LRU Cache (Lecture 16): Similar data structure usage.
  • Rate Limiter (Lecture 17): Similar operation control.
  • Text Editor (Lecture 18): Similar operation management.
  • Movie Ticket Booking (Lecture 19): Similar resource allocation.
  • File System (Lecture 20): Similar hierarchical structure.
  • Logger (Lecture 21): Similar operation logging.
  • URL Parser (Lecture 22): Similar data processing.
  • Q&A System (Lecture 23): Similar user interaction modeling.
  • Traffic Light Controller (Lecture 24): Similar state-driven design.
  • Hospital Management (Lecture 25): Similar resource management.
  • Cache with Expiry (Lecture 26): Similar data management.
  • Notification Dispatcher (Lecture 27): Similar operation dispatching.
  • Inventory Manager (Lecture 28): Similar resource tracking.
  • Matchmaking Engine (Lecture 29): Similar queue-based processing.
  • Telemetry Collector (Lecture 30): Similar data aggregation.
• Clean Code (Section 9): Meaningful names for classes and methods.

5. Use Case

Conduct a mock LLD interview designing a library management system, creating a live class diagram and implementing core functionality in Java.

System Design

Architecture

[Client] --> [LibraryController]
                |
                v
            [LibraryService]
                |
                v
           [Library] --> [Book]
           [User]
           [BorrowRecord]

• Classes:
  • Book: Represents a book with ID, title, and availability.
  • User: Represents a user with ID and name.
  • BorrowRecord: Tracks borrowing details.
  • Library: Manages books, users, and borrowing.
  • LibraryService: Handles business logic.
  • LibraryController: Exposes API.
• Functionality: Add books/users, borrow/return books, check availability.
• Trade-Offs:
  • Storage: In-memory (fast, volatile) vs. database (persistent, slower).
  • Borrowing: Simple availability check (fast, less robust) vs. reservation system (complex, robust).

Code Example: Library Management System

Below is a Java implementation of a library management system with a focus on class diagramming for a mock LLD interview.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Custom exception
public class LibraryException extends Exception {
    public LibraryException(String message) {
        super(message);
    }
}

// Book class
public class Book {
    private String bookId;
    private String title;
    private boolean available;

    public Book(String Patron) {
        super(bookId, title);
        this.bookId = bookId;
        this.title = title;
        this.available = true;
    }

    public String getBookId() {
        return bookId;
    }

    public String getTitle() {
        return title;
    }

    public boolean isAvailable() {
        return available;
    }

    public void setAvailable(boolean available) {
        this.available = available;
    }
}

// User class
public class User {
    private String userId;
    private String name;

    public User(String userId, String name) {
        this.userId = userId;
        this.name = name;
    }

    public String getUserId() {
        return userId;
    }

    public String getName() {
        return name;
    }
}

// Borrow record class
public class BorrowRecord {
    private String recordId;
    private String bookId;
    private String userId;
    private long borrowDate;

    public BorrowRecord(String recordId, String bookId, String userId, long borrowDate) {
        this.recordId = recordId;
        this.bookId = bookId;
        this.userId = userId;
        this.borrowDate = borrowDate;
    }

    public String getRecordId() {
        return recordId;
    }
}

// Library class (Singleton)
public class Library {
    private static Library instance;
    private Map<String, Book> books;
    private Map<String, User> users;
    private Map<String, BorrowRecord> records;

    private Library() {
        this.books = new HashMap<>();
        this.users = new HashMap<>();
        this.records = new HashMap<>();
    }

    public static Library getInstance() {
        if (instance == null) {
            instance = new Library();
        }
        return instance;
    }

    public void addBook(String bookId, String title) throws LibraryException {
        if (books.containsKey(bookId)) {
            throw new LibraryException("Book already exists: " + bookId);
        }
        books.put(bookId, new Book(bookId, title));
    }

    public void addUser(String userId, String name) throws LibraryException {
        if (users.containsKey(userId)) {
            throw new LibraryException("User already exists: " + userId);
        }
        users.put(userId, new User(userId, name));
    }

    public void borrowBook(String recordId, String bookId, String userId) throws LibraryException {
        Book book = books.get(bookId);
        User user = users.get(userId);
        if (book == null) {
            throw new LibraryException("Book not found: " + bookId);
        }
        if (user == null) {
            throw new LibraryException("User not found: " + userId);
        }
        if (!book.isAvailable()) {
            throw new LibraryException("Book not available: " + bookId);
        }
        if (records.containsKey(recordId)) {
            throw new LibraryException("Record already exists: " + recordId);
        }
        records.put(recordId, new BorrowRecord(recordId, bookId, userId, System.currentTimeMillis()));
        book.setAvailable(false);
    }

    public void returnBook(String recordId) throws LibraryException {
        BorrowRecord record = records.get(recordId);
        if (record == null) {
            throw new LibraryException("Record not found: " + recordId);
        }
        Book book = books.get(record.getBookId());
        if (book == null) {
            throw new LibraryException("Book not found: " + record.getBookId());
        }
        book.setAvailable(true);
        records.remove(recordId);
    }

    public boolean isBookAvailable(String bookId) throws LibraryException {
        Book book = books.get(bookId);
        if (book == null) {
            throw new LibraryException("Book not found: " + bookId);
        }
        return book.isAvailable();
    }
}

// Service layer
public class LibraryService {
    private final Library library;

    public LibraryService(Library library) {
        this.library = library;
    }

    public void addBook(String bookId, String title) throws LibraryException {
        library.addBook(bookId, title);
        System.out.println("Added book: " + title);
    }

    public void addUser(String userId, String name) throws LibraryException {
        library.addUser(userId, name);
        System.out.println("Added user: " + name);
    }

    public void borrowBook(String recordId, String bookId, String userId) throws LibraryException {
        library.borrowBook(recordId, bookId, userId);
        System.out.println("Borrowed book: " + bookId + " by user: " + userId);
    }

    public void returnBook(String recordId) throws LibraryException {
        library.returnBook(recordId);
        System.out.println("Returned book: " + recordId);
    }

    public boolean checkAvailability(String bookId) throws LibraryException {
        return library.isBookAvailable(bookId);
    }
}

// Controller for API interactions
public class LibraryController {
    private final LibraryService service;

    public LibraryController(LibraryService service) {
        this.service = service;
    }

    public void handleAddBook(String bookId, String title) {
        try {
            service.addBook(bookId, title);
        } catch (LibraryException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public void handleAddUser(String userId, String name) {
        try {
            service.addUser(userId, name);
        } catch (LibraryException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public void handleBorrowBook(String recordId, String bookId, String userId) {
        try {
            service.borrowBook(recordId, bookId, userId);
        } catch (LibraryException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public void handleReturnBook(String recordId) {
        try {
            service.returnBook(recordId);
        } catch (LibraryException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public boolean handleCheckAvailability(String bookId) {
        try {
            return service.checkAvailability(bookId);
        } catch (LibraryException e) {
            System.err.println("Error: " + e.getMessage());
            return false;
        }
    }
}

// Client to demonstrate usage
public class LibraryClient {
    public static void main(String[] args) {
        Library library = Library.getInstance();
        LibraryService service = new LibraryService(library);
        LibraryController controller = new LibraryController(service);

        // Mock interview flow
        controller.handleAddBook("book1", "Java Programming");
        controller.handleAddUser("user1", "Alice");
        controller.handleBorrowBook("record1", "book1", "user1");
        System.out.println("Book available: " + controller.handleCheckAvailability("book1"));
        controller.handleReturnBook("record1");
        System.out.println("Book available: " + controller.handleCheckAvailability("book1"));

        // Edge cases
        controller.handleAddBook("book1", "Duplicate Book"); // Duplicate book
        controller.handleBorrowBook("record2", "book2", "user1"); // Non-existent book
        controller.handleBorrowBook("record2", "book1", "user2"); // Non-existent user
        controller.handleReturnBook("record3"); // Non-existent record
        // Output:
        // Added book: Java Programming
        // Added user: Alice
        // Borrowed book: book1 by user: user1
        // Book available: false
        // Returned book: record1
        // Book available: true
        // Error: Book already exists: book1
        // Error: Book not found: book2
        // Error: User not found: user2
        // Error: Record not found: record3
    }
}

• LLD Interview Principles:
  • Class Diagramming:
    • Start with entities: Book, User, BorrowRecord, Library.
    • Define relationships: Library has many Book and User; BorrowRecord links Book and User.
    • Use UML notation (arrows, multiplicity) to show associations.
  • Interview Strategy:
    • Clarify requirements (e.g., in-memory, basic borrowing).
    • Sketch UML live, explaining classes and methods.
    • Discuss trade-offs (e.g., in-memory vs. database).
  • Classes: Book, User, BorrowRecord, Library, LibraryService, LibraryController.
  • Design Patterns: Singleton (Library), Observer (extensible for notifications).
  • Clean Code: Meaningful names, modularity (Section 9).
  • Design Principles: SoC (Section 4, Lecture 11) separates business and controller logic; KISS (Lecture 8) simplifies design.
• Big O: O(1) for addBook, addUser, borrowBook, returnBook, isBookAvailable (HashMap operations).
• Edge Cases: Handles duplicate books/users, non-existent books/users/records.

UML Diagram:

[Client] --> [LibraryController]
                |
                v
            [LibraryService]
                |
                v
           [Library]
                |
                v
           [Book] --> [BorrowRecord]
           [User]

Real-World Application

Imagine participating in a FAANG LLD interview, designing a library management system live. This LLD—aligned with HLD principles from Section 5 (e.g., Library Management, Lecture 11)—demonstrates your ability to create clear class diagrams and modular code, critical for interview success.

Practice Exercises

Practice LLD interview skills with these exercises:

• Easy: Create a UML class diagram for a simple library system with one class.
• Medium: Implement a library system in Java with basic book management.
• Medium: Design an LLD for a library system with borrowing functionality and draw a UML diagram.
• Hard: Conduct a mock LLD interview, designing a system (e.g., library, parking lot) live with UML and Java.

Try designing one system in Java with a UML diagram, explaining your thought process as in an interview.

Conclusion

Mastering LLD interviews through live class diagramming equips you to excel in FAANG interviews and design robust Java systems. This lecture builds on HLD concepts and LLD principles, preparing you for real-world challenges.

Next Step: Explore Design a Parking lot System to continue your LLD journey, or check out all sections.

---

Connect: GitHub | LinkedIn

Contact: your-email@example.com

© 2025 Official CTO. All rights reserved.