The Start of My System Design Journey
Why I started learning system design
In the current tech job market, it is no longer enough to have just DSA knowledge and basic development skills, because of AI, these skills have become the bare minimum. What most recruiters are looking for are engineers who can effectively utilise AI to build production systems much more efficiently. And one of the most sought-after skills now is about building projects with minimal AI token usage while maintaining productivity.
To make AI work for you effectively, it is important to have a deep understanding of the system you are trying to build. Without a proper understanding of the system, you cannot direct AI to code it properly, and you will have to go back and forth with long prompt conversations to make AI do things the way you want it to.
So I decided to focus on learning system design, starting with low-level design (LLD) first.
Topics I covered so far
1. 4 Pillars of Object-Oriented Programming:
I started by learning the 4 pillars of OOP, which were easy for me since I learned about all the pillars — Abstraction, Encapsulation, Inheritance, and Polymorphism in my Bachelor’s. And I’ve been making Python projects for over 3 years, utilising these concepts throughout my projects. So this part was a breeze.
2. SOLID Principles:
I had never studied this topic before, so I struggled with it. The five solid principles are easy by definition, but analysing the code for checking whether it follows these principles or not was difficult.
Single Responsibility, Open-Closed, and Interface Segregation principles were easy to understand and recognise. I had no issues with analysing code for these principles since they are super straightforward and simple to implement.
The problems I had the most were with the Liskov Substitution Principle and the Dependency Inversion Principle. I had difficulties with not only their implementation but also understanding their meaning. Finding violations of these two principles in code was very difficult for me, and I had to practice a lot to get them right. For each principle, I prompted AI to give a practice question that violates that principle, which I fix and then submit for review. This worked great for understanding purposes. After solving a bunch of these practice problems, I was able to recognise any violations and fix them. SOLID principles were the foundation for the entire LLD, so I spent extra time on them.
3. Design Patterns:
After learning SOLID patterns, I shifted my focus to learning some common design patterns that were widely used. I didn’t spend time learning every one of them mentioned in the Gang of Four book. Instead, I focused on the most used and common ones. I learned Factory, Strategy, Observer, Template, Facade, Singleton, and Decorator patterns. After learning about SOLID principles, understanding the intuition behind these patterns was simple, but some of them still violated the principles, like having more than one responsibility. But I came to realise that these are just principles and not laws, so if there’s a functionality we need, then it’s alright to violate them.
As I went deep into each pattern, I also learned about the pros and cons of each one. This was the first time I realised that in system design, there are no right or wrong answers, only trade-offs.
4. UML Diagrams:
I learned how to draw UML diagrams for designing systems. There are many diagrams, but I focused mainly on the Class diagram since that is the most widely used in LLD. I learned the components, notations, and different types of relationships between classes.
Get Atharv Verma’s stories in your inbox
Join Medium for free to get updates from this writer.
After learning these diagrams, I understood why they are used; it makes development so much easier if your diagrams are accurate and detailed. Just by providing AI with a proper class diagram, it can reliably code most of the system correctly, where only minor edits are needed. Learning about these diagrams made me realise development would’ve been so much simpler if I had learned them 3 years ago!
Solving my first LLD interview Problems
1. Parking Lot System:
For my first problem, I decided to solve the parking lot system. Everyone says that it is the most basic and beginner problem, so I gave it a try. First, I attempted it without any help. I figured out the requirements of the system and figured out the different entities and relationships between them. But when I started to draw the UML diagram, I had so much difficulty in figuring out the attributes and the methods for each class. After struggling for a good hour, I decided to look up some solutions. After understanding those solutions, I had a much better understanding of the system, and I tried to design the classes again.
Even after all this, I couldn’t complete the class diagram, so I had to move on to coding the system. Coding the system with a complete class diagram is so easy. The thing I realised was that SOLID principles are violated so much during coding, even if we use design patterns, and the aspect of trade-offs in system design became even more apparent. Many times I was stuck on deciding what pattern to use and what benefit will that bring. I never thought about this before, but exploring different solutions to the same problem made me aware of so many design choices at a deeper level that I never once considered.
Check out the repo: https://github.com/Atharv-Verma290/LLD/tree/main/ParkingLot
2. Tic Tac Toe System:
After solving the parking lot system, I solved the tic-tac-toe problem. This time, I was a little bit better at designing the UML diagram, but I still had to look up some solutions for it. But I was able to design the system and even add two more design patterns that weren’t in the solutions I found online.
Check out the repo: https://github.com/Atharv-Verma290/LLD/tree/main/TicTacToe
Key Lessons
The most important thing I learned this week was SOLID principles and design patterns. By learning these, I was starting to understand how to design systems using UML diagrams and what mindset to have when designing a system.
What’s Next
I will continue to practice LLD interview questions to get good at it, and I will also try to implement LLD in my personal projects as well. After practising a bunch of LLD questions, I will move to learning High Level Design.
