NOTE: - I started my 8-week system design journey with Coder Army. I will be journaling every day, recording what I learn, reflecting on it, and sharing it with my network to help newcomers to system design.

📌 Introduction

Welcome to Week 2 of my Low-Level Design (LLD) journey!
In Day 6 and Day 7, I focused on applying the SOLID principles by solving a hands-on design problem:
🎯 Redesigning an Image Editor system using clean object-oriented practices.

This blog post walks through the thought process, class structure, code, and implementation in Java using VS Code.

📍Qs 1)

💠 Step 1: Understand the Problem

From the image:

• The ImageEditor class has too many responsibilities:

  • Capturing an image

  • Editing operations (crop, sharpen, apply color)

  • Saving the image

• This violates the Single Responsibility Principle (SRP).

• Also, if we add a new filter or save to a different database, we'll have to modify this class — violating Open/Closed Principle (OCP).

💠 Step 2: Apply SOLID Principles

We'll redesign the system using the following:

✅ Solution Using SOLID:

1. SRP:

   • Split responsibilities: Camera → capture, Editor → apply filters, Storage → save

2. OCP:

   • Introduced interfaces (Filter, Storage) to allow new features without changing existing code

3. DIP:

   • ImageEditor and Main depend on abstractions, not concrete classes

💠 Code: My GitHub Repo

🔗 GitHub: Image Editor Using SOLID Principles

📍Qs 2)

💠 Step 1: Understand the Problem Statement

The task is to build a flexible sorting module that supports multiple sorting strategies such as:

• ✅ QuickSort: Standard & Randomized

• ✅ MergeSort: Normal & In-Place

• ✅ Should allow for easy addition of new algorithms (like HeapSort)

• ✅ Should allow for order direction (Ascending / Descending)

• ✅ Should follow OOP best practices, especially the Strategy Pattern

💠 Step 2: Apply SOLID Principles

✅ SOLID Principles Applied (Sorting Context LLD)

🔹 SRP (Single Responsibility)
Each class has one job:

• SortHandler: Delegates sorting

• QuickSortStrategy, MergeSortStrategy: Implement specific sorting logic

🔹 OCP (Open/Closed)
Add new strategies (e.g., HeapSort) without changing existing code.
→ Thanks to the SortStrategy interface.

🔹 LSP (Liskov Substitution)
All strategies (QuickSort, MergeSort) can be used interchangeably via SortStrategy.

🔹 ISP (Interface Segregation)
The SortStrategy interface is minimal — only one method: sort(int[], boolean).
No unnecessary code for strategy classes.

🔹 DIP (Dependency Inversion)
SortHandler depends on the interface SortStrategy, not concrete classes.
→ Promotes loose coupling and easy testing.

💠 Code: My GitHub Repo

🔗 GitHub: Image Editor Using SOLID Principles

Week -2 (Day 6 & 7) Completed ✅ System Design

NOTE : - A big thanks to my mentors Rohit Negi Sir and Aditya Sir for launching this amazing 8-week course absolutely free on YouTube via CoderArmy9 :- https://www.youtube.com/@CoderArmy9🙌

👉 Share this blog with your connections! Let’s keep learning, growing, and supporting one another on this journey. 🚀

✍️ Payal Kumari 👩‍💻

Jai Hind 🇮🇳 | #CoderArmy #LearningInPublic #SystemDesign #TechForAll #MentorshipMatters #8weeksLLdChallenge #LowLevelDesign #Code #LLD