Table of Contents
Introduction
Hi everyone. This article is the continuation of the previous blog about “High Level Design“. In this article I will be going to cover the complete roadmap of “Low Level Design”. Now whenever we talk about system design, Low Level Design is a very important concept. Especially if we are targeting SDE2 or higher roles. And if we want to become a CTO and a tech lead in the future. Because in system design we cover many such important concepts which are very important for designing highly scalable robust systems.
When preparing for FAANG interviews, one of the most important areas is System Design. While High Level Design (HLD) focuses on large-scale architecture systems, Low Level Design (LLD) is all about machine coding – writing clean and structured code.
Low Level Design Fundamentals
Start will learning the fundamental concepts of OOPs(Object-Oriented Programming). As LLD is about writing well-structured code which solves the problems, so it is important to cover all the four pillars or OOPs which are – Encapsulation, Inheritance, Polymorphism Abstraction. These serve as the foundation for structured code design.
SOLID principles
The next step would be to learn the 5 SOLID principles. Now what are SOLID principles? These are 5 design principles which help to make object-oriented designs more understandable, flexible and maintainable.
- S – Single Responsibility Principle (SRP) – Each module or class should be responsible for only a single piece of functionality
- O – Open/Closed Principle (OCP) – Software entities should be open for extension but closed for modification.
- L – Liskov Substitution Principle (LSP) – if a function works with a base class object, it must also work with a derived class object.
- I – Interface Segregation Principle (ISP) – This means splitting large interfaces into smaller, more specific ones.
- D – Dependency Inversion Principle (DIP) – High-level modules and low-level modules, both should depend on abstractions (example: interfaces).
These principles should be studied in detail as they are frequently tested in FAANG interviews.
Design Patterns
There are many common coding problems which can solved using design patterns. Most of us unknowingly use them in our daily work as software engineers. Therefore you must know about these patterns in detail.
Types of Design Patterns – Creational Patterns , Structural Patterns , Behavioral Patterns. Knowing when and where to apply these pattern to solve problems is a must know. These are crucial part of Low Level Design.
Concept of Concurrency and Thread Safety
Along with the above concepts, you must be familiar with the concept of concurrency and thread safety. Concurrency play a huge role in Low Level Design(LLD). Your ability to handle multi-threaded environment is often tested in FAANG interviews. Along with this there are few other topics which you should know about from Operating System Fundamentals:-
- How thread safety injection happens?
- What are the different locking techniques?
- The producer-consumer model
- Race conditions and Synchronization
UML Diagrams
The next step would be to learn about UML(Unified Modeling Language) Diagrams. Basically, these are diagrams or blueprints that help visualize complex systems and software. The four pillars of OOPS can be visualized through these diagrams. There are many different types of Diagrams – Class diagrams, Component diagrams, Deployment Diagrams, Activity diagrams, Use case diagrams etc. Not all companies require them. Some interviewers may skip UML entirely, while others expect it. Check out this article to learn more about the Diagrams – https://www.geeksforgeeks.org/system-design/unified-modeling-language-uml-introduction/
API Design Principles
Application Programming Interface (API) is the backbone of most modern applications and important for Low Level Design.
Key areas to focus on:
- Avoiding God Classes for maintainability
- Request-Response Object Modeling
- API Versioning & Extensibility
- Clean Code Practices in APIs
So these are all important concepts required to write code for APIs.
Conclusion
Now in Low Level Design and High Level Design, you will notice a difference that in HLD generally we are designing a large system. And in LLD we have a comparatively small system which we have to code. Like a T2 or a chess game and maybe you are designing a notification system and a URL shortener. So in this way there are small systems which we have to code.
Now if we talk about the timeline for learning all of these things. If we are someone who is a software engineer and is actively preparing for software engineering interviews. And there are many of these concepts which they have been learning and using in their work on a day to day basis. So in such a case it will take us two to three months to learn all these concepts. But if we are someone for whom majority of the concepts were new and they had heard for the first time. So in such a case a realistic timeline would be between four to six months. But the key to learning system design is always practice practice and more practice. Because the more we practice these concepts, the more we try to implement these concepts in our POCs, in fact in personal projects, the more we will be able to dive, deep and understand system design better.
So, I hope this article will be helping you positively somewhere in your career. And to the best of my knowledge, this is going to be one of the most crystal clear and comprehensive system design guide. That’s all for this article. See you in the next one. Till then keep learning and keep exploring!
For more such articles. Visit upskillltoday.com