Design Thinking

Design Thinking is a systematic, human-centered approach to solving complex software engineering challenges. Before drawing class models or writing execution logic, you must understand the problem constraints, define entities, and build low-fidelity prototypes.

1. Learning Objectives

• Apply the five phases of Design Thinking (Empathize, Define, Ideate, Prototype, Test) to code architecture.
• Translate descriptive product specifications into class structures and system requirements.
• Validate designs using scenario-based walkthroughs before implementation.

2. Problem Statement

Most software project failures do not stem from bad coding skills, but rather from building the wrong solution.

• Without Design Thinking: Engineers jump straight to implementation. They build models without clarifying assumptions, resulting in missing functionalities and large-scale structural rework.
• With Design Thinking: Requirements are gathered, entities are mapped, and edge-cases are accounted for prior to coding.

3. Real-world Analogy

4. Theory

Applying Design Thinking to LLD translates into five concrete stages:

• Empathize: Gather requirements. What are the users doing? Clarify constraints (e.g. "Can a user have multiple wishlists?").
• Define: Outline the domain model. Identify entities (Nouns in specifications) and operations (Verbs in specifications).
• Ideate: Draft design alternatives. Should we use inheritance or composition? Which design patterns fit?
• Prototype: Draw UML class structures and sketch interfaces.
• Test: Write unit tests and run dry-run walkthroughs against specific scenarios.

5. Visual Diagram

This flowchart visualizes the design thinking loop applied to software design:

6. Syntax Explanation

When defining domain structures, we use Composition to represent "Has-A" relationships (e.g. a Wishlist has a collection of Product objects).

• In Java, collections are declared via List or Set.
• In Python, we use type hinting like List[Product] to declare relationships.
• In C++, we use smart pointers std::vector>.

7. Step-by-Step Implementation

Let's design a simple Product Catalog Wishlist based on the following requirement: *"A customer can add products to a custom wishlist and display them."*

• Step 1: Identify Nouns: Product, Wishlist. Identify Verbs: addProduct, getProducts.
• Step 2: Declare the Product entity.
• Step 3: Declare the Wishlist class, containing a collection of Products.
• Step 4: Write the client code to simulate and verify this flow.

8. Complete Code

9. Code Walkthrough

In the Wishlist class, we shield the internal products list. Returning Collections.unmodifiableList(products) in Java or a copy of the list in Python/C++ blocks clients from editing the wishlist contents without going through the class's addProduct() method.

10. Execution Flow

• Create Product instance on the heap.
• Create Wishlist instance on the heap.
• Invoke wishlist.addProduct(product), passing the reference pointer.
• Verify addition by requesting the unmodifiable collection and asserting size.

11. Internal Working

Returning an unmodifiable wrapper in Java allocates a lightweight read-only view in the Heap that points to the original list. If a client attempts to execute .add() on this wrapper, a runtime UnsupportedOperationException is thrown, protecting internal state.

12. Complexity Analysis

• Time Complexity: $O(1)$ to append a product reference to the array list.
• Space Complexity: $O(1)$ extra space used per element.

13. Best Practices

• List constraints first: Always clarify constraints (e.g. maximum wishlist capacity) in the empathize phase.
• Return read-only collections: Protect internal lists from direct external writes.
• Write test specs: Mock client scenarios to test edge cases.

14. Common Mistakes

• Returning direct references to mutable internal lists, which bypasses class encapsulation.
• Failing to validate inputs (e.g. allowing null products to be added to the list).

15. Interview Questions

16. Practice Exercises

• Easy: Add a method removeProduct(Product product) to the Wishlist class.
• Medium: Add a constraint to limit the wishlist to a maximum of 10 items. Throw an exception when exceeded.
• Hard: Build a dynamic sharing mechanism allowing users to share their wishlist with other users in read-only mode.

17. Challenge Problem

Design an encapsulated Shopping Cart class where discounts can be applied dynamically using different coupon structures.

18. Summary

• Design Thinking centers software development around user needs.
• Noun-verb analysis translates textual requirements into class blueprints.
• Encapsulated lists should be wrapped to block external writes.

19. Cheat Sheet

20. Quiz

21. Next Lesson Preview

Congratulations! You have completed the LLD Introduction module. In the next module, OOP Fundamentals, we begin with Classes and Objects to explore the core pillars of object-oriented design!