How I Study System Design Without Forgetting Everything - 雙語字幕
So when I first started to do a lot of software interviews and I was asked to do system design interviews,
I looked online for all kinds of different ways to.
find a systematic way to study.
You for lead code, it was like, go through this list, go through that list, learn this data structure and algorithm.
But system design, there didn't seem to be a specific way that people studied.
I took that advice to heart and a lot of the times in my past interview experiences,
I would leave system design as something that I would just wing on the interview, you know.
The interview would come and I would just start to like make shit up and then hope that it would work out.
But based on my experience, system design is one of those things that.
know it or you don't.
An is kind of gonna know if you know what you're talking about or if you're just making things up because you don't know what
you're doing.
So today I wanted to take what I learned over the past couple months and the past years of me interviewing myself and try to explain my
own process for studying system design now.
So let's start with active learning.
Okay, to start with what I've done in the past.
The way I study systems I have in the past was I use this system design primer, GitHub repo.
This is posted all over Reddit, and I'll post it in the comments down below, or in the comments section, the description, sorry.
But basically, this is a gigantic read me doc that is pushed to GitHub.
that explains every little system design nuance you could possibly think of.
And this worked very well.
It has a whole bunch of different papers that it links to and a whole bunch of different links and blogs and everything like that.
This is an excellent tool for you to use to study system design.
But the thing about it is that people learn slightly differently based on who they are.
And me, reading things, I just learn very, very slowly, and it's difficult for me to grasp a lot of information.
So I use this more as just one of my sources.
The source I've been using most commonly in the past couple of months is a YouTube channel has no life.
This guy basically has made a whole bunch of videos about the system design basics like described in the earlier GitHub repository that I was talking about,
but he's also made a ton of videos about designing all kinds of different systems.
And the thing about his videos is that he is super in depth.
More in depth and I've seen pretty much any youtuber out there go where he'll take a problem and you'll
really really drill down into what happens and why it happens that way.
The most obvious example probably is when he talks about database indexes.
Basically he goes very deep into how the database actually stores the data,
how it actually does everything behind the scenes, like what types of data structures are using.
It basically shows you that a lot of system design and how technology is built out there, isn't magic.
Like behind the scenes don't just run because you know, there's some sort of crazy, algorithm behind there.
They're all just data structures and algorithms just like we've learned in all computer science classes.
So if you're a person who really likes to watch videos to learn your information and to learn how to study,
I would recommend you check out this YouTube channel,
which basically he has a whole set of videos for
Every single small piece of the system design puzzle that you need for interviews He's about like 60 or so videos.
I watched all of them They're great and then he has about like 30 or so videos just designing very common systems that we use on a daily
basis You know like Facebook Instagram twitch stuff like that discord and when you're watching this videos,
it can be really easy to feel like you're being very productive,
you know, like you sat here for an hour watching the video and you feel really good about yourself.
But the thing about it is if you don't take notes and review them in a careful way,
you can be very easily kind of wasting your time a little bit.
A lot of the times when I said the system design passed, I never really took a lot of effort to take notes.
I just look at things and then be like, okay, I got it and move on.
So I designed myself a pretty systematic way of taking notes, which I will talk about later.
And the last system design interview tool that I use is called Grocking the System Design Interview,
which is also kind of a meme on Reddit and other sources and everything like that.
But objectively, it's a very good resource.
It does one thing that the videos and the other GitHub repo that I showed does not do,
which gives you a systematic way on how to actually In system design how to break down your questions in a way where your interviewer won't be confused
Which is where I move into the next section for practicing.
So in real life when you're doing a system design You're working with a real person who's asking questions back and forth.
He's trying to pick apart your design.
He's trying to see how you would optimize certain things.
So it's more of a conversation with someone.
And this is where this groking, this isn't design interview comes into play for me.
Basically, what it does really well is give you a step-by-step guide on how to talk to interviewers, right?
Like step one,
you clarify requirements with your interviewer just to make sure you're understanding like the scale and scope and what kinds of things you're going to be designing
two is back of the envelope estimation where you try to estimate like network bandwidth,
you're trying to estimate like how much you need for caching,
how much storage you need for disk memory, how many machines you might need to determine the true scale of your system and everything.
The third step was always like API design, basic stuff just to show what are the inputs and outputs of your system.
The fourth step is divining a data model,
which is basically like how data in your database is going to work and how it's going to be laid out.
And the fifth step is like a high level design where you just draw
your whole application and the general places where all the little components of your system will be,
which will show your interviewer from all these steps that you generally know we were talking about.
And then it has a six and a seven step, which is really quantify in like a online tutorial course or like that.
But this is basically where in a real interview interview we'll ask you questions about,
you know, how do you optimize this or like, how would you do this in a different way?
Or like, why did you choose this for your solution instead of this other thing?
So given that whole template, I mentioned earlier that I'm using different sources to actively learn.
But then applying those concepts and practicing practicing them are just as important, if not more important.
What I do with this is I use that format that I just talked about, and then I essentially quiz myself, right?
Like I go through these things,
I look what the requirements are, and then I try to draw it out myself as if I'm testing myself.
Like I'm doing the back of the napkin math in order to estimate capacity,
which side note, if you're like me and you're really bad at mental math.
this shit was actually it's way harder than you expect it took me a while to
completely understand that but anyways I calculate the back of the napkin math
I quiz myself and see if it's right or if my scale is right I'll design the
API's myself and then quiz myself by checking okay are they right like did I
have the right idea here I'll design my own database model and then kind of look at
the database model here and see okay like this is kind of match up like what
I'm missing and why did I miss it and then from there I try to draw out my own texture,
the you know, drawing with all the components linked together and try to figure out places that are bottlenecked, like things that can be improved.
And then I come to this final section right here, which is where they have all kinds of different questions and answers.
I generally just try to look at the bold ones and see like,
okay, so what are the different issues with our or like, can concurrency cause What problems?
What problems, like what would the DB key size be.
Basically, I'm just pretending that an interviewer is asking me these questions and I try to fix, optimize, or at least understand what I did wrong with my
own solution.
Okay, so the final step of what I've been doing to study system design is reviewing very, very consistently.
I mentioned earlier that when you're learning,
especially if you're watching videos or reading a lot of text, it's important to make sure that you're recording everything that you're doing.
So for me, you know, I'm a notion nerd, as you might know, and I basically created this notion database.
using the active recall format.
If watched my Elite Code video,
you know that I love the active recall format,
which is basically,
you know,
as I'm watching these videos,
as I'm like reading this stuff right here,
I'm trying to constantly ask myself question, like I'm trying to ask myself like, how does this little component work?
Or like, what would I need for this other thing?
Or, why would I use this component over this component?
Stuff like that.
And I basically write all these questions down and I tag them by the topic specifically.
So first I did it by topic like while I was learning these systems and concepts,
I went through all those videos from earlier that I showed you and I would ask myself like,
okay, what is it from this video that I could ask myself later?
something that I don't really know that well.
So just pulling up a random example, if we're going to look at caching, I would write the question, explain right back cache.
And while I'm reviewing, I would cover up the answer.
And this is where I would try to explain it for myself.
I would try to look, look at the question only, and then try to put the answer in my own terms.
And then if I really can't get it, then I just look over at the answer and read back to myself.
Okay, so what did I write before?
And what did I get wrong?
At which point,
if I struggle with that concept,
then I'll make sure to mark it down as a question that I need to review, and something that I struggle with more.
So had this checkbox right here in this same database for me to do that.
I know a of this stuff is a lot of work,
but generally,
if we just learn actively,
we take notes with the active recall method,
and we practice system design over and over, I don't see how there's a way we can't move forward.
Lately, I found myself understanding these concepts and really just understanding how the world of technology works around me.
And really brought back a lot of my passion for software engineering.
So anyways, that's it for me today.
If you want to check out another video about my lead code study process, I'll put that on the screen somewhere over here.
But yeah, as always.
解鎖更多功能
安裝 Trancy 擴展，可以解鎖更多功能，包括AI字幕、AI單詞釋義、AI語法分析、AI口語等
兼容主流視頻平台
Trancy 不僅提供對 YouTube、Netflix、Udemy、Disney+、TED、edX、Kehan、Coursera 等平台的雙語字幕支持，還能實現對普通網頁的 AI 劃詞/劃句翻譯、全文沉浸翻譯等功能，真正的語言學習全能助手。
支持全平臺瀏覽器
Trancy 支持全平臺使用，包括iOS Safari瀏覽器擴展
多種觀影模式
支持劇場、閱讀、混合等多種觀影模式，全方位雙語體驗
多種練習模式
支持句子精聽、口語測評、選擇填空、默寫等多種練習方式
AI 視頻總結
使用 OpenAI 對視頻總結，快速視頻概要，掌握關鍵內容
AI 字幕
只需3-5分鐘，即可生成 YouTube AI 字幕，精準且快速
AI 單詞釋義
輕點字幕中的單詞，即可查詢釋義，並有AI釋義賦能
AI 語法分析
對句子進行語法分析，快速理解句子含義，掌握難點語法
更多網頁功能
Trancy 支持視頻雙語字幕同時，還可提供網頁的單詞翻譯和全文翻譯功能