Low Level System Design An interview perspective

Ace the Low Level Design interview by solving problems asked in the System Design round of programming interviews
Low Level System Design An interview perspective
File Size :
2.06 GB
Total length :
6h 36m

Category

Instructor

Abhishek Ghosh

Language

Last update

Last updated 7/2022

Ratings

4.4/5

Low Level System Design An interview perspective

What you’ll learn

Getting ready for System Design [Low Level Design] interviews
Learn different ways to approach a problem and underline key points
Discussing the trade-offs with the interviewer and playing to your strengths
Optimizing code using better data structures, according to the scenario
Insights into problem extensibility, and begin coding with this as the end goal in mind.
Learn to weed out unnecessary information from the problem definition, identify traction, and create a class diagram with it
Learn to write test cases for the problem as and when required
Necessary exposure and modifications to the API for code sustainability
Using encapsulation when required and generate desired accessors and mutators
Learn code completion in due interview time. Gain insight into fallback plans in emergency cases

Low Level System Design An interview perspective

Requirements

Be comfortable with a programming language
Know basics of Object Oriented Programming

Description

Software Engineering interviews focus on the coding and software designing skills in an interview. These are fondly known as Algorithm and Design rounds respectively. The Algorithms round check the raw coding skills of a candidate, by the application of Data Structures and Algorithms mostly practiced in school, while the Design round tests the System design skills, which can be High Level Design [HLD] or Low Level Design [LLD].Low Level Design is also known as Object Oriented Design [OOD] or Object Oriented Analysis and Design [OOAD]. From interns to Senior Software Engineers, top companies dedicate at least one round in the entire interview process for system design. For candidates having less than 3 years’ of experience, Low Level Design plays the most crucial role because these candidates are inexperienced, hence not supposed to have knowledge of High Level Design. Candidates having experience of more than 3 years usually face the system design interviews with a mix of both HLD and LLD.This course Low Level System Design focuses on the low level aspects of the design. The only way to get better at interviews is by practicing lots of similar problems. In this course, based upon my research, a list of most frequently asked questions in interviews is compiled. Not only is this useful for the interviews, but also for general problem solving and application design.Every problem is broken down and discussed in a comprehensive manner:Making the problem statement clear of any ambiguity. Terminologies related to the problem are explained and expectations well laid out.Class Diagram construction serves as a road map for coding the problemThe coding is done in the most elegant manner such that the users learn to approach the problem top-down. This is important because even if the class diagram is in place, it’s imperative to know the sequence of class construction in program, for a smooth experience.Wherever applicable, the code is optimized further. Trade offs related to optimization are also discussed.At last, test case construction is shown to make the candidate wary about writing good test cases, and their impact on the application.All this is done while following industry best practices. Proper time utilization during the interview is also talked about intermittently, and ways to deal with a situation when the candidate is stuck at a problem for a long time. The coding is done in C++ but the code is language agnostic to a great extent.The course also sports Closed Captions [English Subtitles] for all the videos. They are hand-crafted, not auto-generated. This feature is helpful when the student is having problem with the accent, there’s a lot of background noise present, or when you want to make detailed notes from the explanation.After taking this course, youWill be in a better place to face LLD interviews.Can participate in design discussions related to such problemsWrite better code than beforeHave a proper theater to break the problem into pieces and deal with them independentlyGuaranteed TakeawayIf you understand all the problems presented in this course, there won’t be any fear of solving LLD questions. You’ll be asking the right questions about the problem, and will be confident to jab at any design.

Overview

Section 1: Introduction

Lecture 1 Introduction

Section 2: Basic ride sharing application

Lecture 2 Problem Definition

Lecture 3 Design the class for booking a ride

Lecture 4 Design the Rider class depicting the user

Lecture 5 Testing the code for meeting requirements

Lecture 6 #Assumption 1: Single user booking multiple rides at a time

Lecture 7 Exercise: Design an interface for user interaction

Lecture 8 Solution: Design an interface for user interaction

Section 3: Meeting Scheduler

Lecture 9 Problem Definition

Lecture 10 Design the Room class, which hosts a meeting

Lecture 11 Design the class Meeting, which contains meeting details

Lecture 12 Design the class Scheduler

Lecture 13 Core logic for scheduling a meeting

Lecture 14 Testing the code for the given requirements

Lecture 15 Exercise: Extend the application to book meetings across days

Lecture 16 Solution: Extend the application to book meetings across days

Section 4: Task Planner

Lecture 17 Problem Definition

Lecture 18 Design Sprint class

Lecture 19 Design Task class

Lecture 20 Design the User class [1/3]

Lecture 21 Design the User class [2/3]

Lecture 22 Design the User class [3/3]

Lecture 23 Testing the code for the given requirements

Section 5: Bowling Game System

Lecture 24 Problem Definition

Lecture 25 Design a game session for the play

Lecture 26 Design the Game class

Lecture 27 Design the Player class [1/2]

Lecture 28 Design the Player class [2/2]

Lecture 29 Testing the code for the given requirements

Section 6: Snakes And Ladders

Lecture 30 Problem Definition

Lecture 31 Design the base classes for the game

Lecture 32 Design the Game class of the problem

Lecture 33 Testing the code for the given requirements

Section 7: Money share/transfer application like Splitwise

Lecture 34 Problem Definition

Lecture 35 Design the User class

Lecture 36 Design the Expense class

Lecture 37 Designing the class Splitwise [1/3]

Lecture 38 Designing the class Splitwise [2/3]

Lecture 39 Designing the class Splitwise [3/3]

Lecture 40 Testing the code for the given requirements

Lecture 41 Optimizing the code

Lecture 42 Exercise: Simplify Expenses

Lecture 43 Solution: Simplify Expenses

Section 8: Facebook Comment System

Lecture 44 Problem Definition

Lecture 45 Design the Comment class

Lecture 46 Design the Post class

Lecture 47 Design the User class

Lecture 48 Testing the code for the given requirements

Section 9: Sales Management System

Lecture 49 Problem Definition

Lecture 50 Design the Store class

Lecture 51 Design the City class

Lecture 52 Design the State class

Lecture 53 Design the System class

Lecture 54 Testing the code for the given requirements

Section 10: Text Editor application

Lecture 55 Problem Definition

Lecture 56 Designing the Notepad class [1/2]

Lecture 57 Designing the Notepad class [2/2]

Lecture 58 Testing the code for the given requirements

Section 11: Employee Management System

Lecture 59 Problem Definition

Lecture 60 Design the Employee class

Lecture 61 Design the System class

Lecture 62 Testing the code for the given requirements

Section 12: Book Catalog System

Lecture 63 Problem Definition

Lecture 64 Design the Book class

Lecture 65 Design the Catalog class

Lecture 66 Testing the code for the given requirements

Section 13: Job Scheduler

Lecture 67 Problem Definition

Lecture 68 Design the Job class

Lecture 69 Design the Scheduler class [1/2]

Lecture 70 Design the Scheduler class [2/2]

Lecture 71 Understand the Test Cases

Lecture 72 Testing the code for the given requirements

Section 14: Addendum

Lecture 73 Extra tips for beginners

Software Engineers,Aspiring Software Engineers

Course Information:

Udemy | English | 6h 36m | 2.06 GB
Created by: Abhishek Ghosh

You Can See More Courses in the Developer >> Greetings from CourseDown.com

New Courses

Scroll to Top