.png?w=420)
Large-Scale Systems Design Part 1
Jayce
Learn common components of global-scale services through popular papers, books, and articles.
Basic
software-design, DBMS/RDBMS
Learn and create Git actions yourself, the de facto standard for version control tools!
63 learners
Level Basic
Course period Unlimited

Git Internals
System Programming
Can you explain what happens internally in Git when you type git checkout and git commit " commands? This lecture will explore the internal algorithms and file system operations behind Git's core operations, and teach you how to create "Tig," a Git-like implementation, in a language you're familiar with.
Q. The course is taught in Go. Do I need to know Go?
A. The lecture covers basic control and looping constructs, assignment, data types, and more, all of which are comparable to those in other languages. Go has a very simple syntax. Its packages for systems programming are also very intuitive. Therefore, you should have no trouble following the lectures in your own language.
Q. Do I need to know system programming?
A. We teach basic system programming in this course. The system programming used in the lecture exercises isn't complicated. It's basic system programming, covering creating, writing, and reading files. However, you'll need to research how to do this in your own practice language.
Q. Is there a Git command tutorial included?
A. While Git commands are explained during the course, they aren't as detailed as those used by beginners. This course requires some prior experience with Git.
Who is this course right for?
Anyone curious about the inner workings of Git
Anyone who wants to become an attractive developer through Deep Dive
Anyone who wants to study one of the world's open sources in depth
Need to know before starting?
One programming language you are confident in
406
Learners
17
Reviews
4
Answers
4.8
Rating
2
Courses
Hello. I'm Jayce. I am currently working as a platform engineer at a unicorn startup.
In a short period of time, I have founded a startup, developed large-scale services, and built platforms for developers, taking on roles as both a service developer and a platform engineer. Through these experiences, I have been able to define for myself the characteristics of a "great software engineer" and what it takes to become one.
In short, I find people who take a "deep dive" to be attractive as fellow engineers. I feel that those who simply churn out assigned tasks like a machine tend to take relatively longer to make the best choice in a given situation. On the other hand, those who dig deep into the underlying engineering reasons behind a decision quickly become the type of people who can provide strong, engineering-based arguments for other decisions as well.
The courses I create do not aim for a shallow understanding of new technologies. I want to teach junior developers how to become great teammates, attractive developers, and solid engineers. I will put forth my best effort to create courses suitable for those who wish to study deeper topics to become more compelling engineers. 🙂
All
36 lectures ∙ (6hr 46min)
Course Materials:
8. Objects
01:48
9. Objects: Blob
06:54
10. HashObject: Spec
12:51
12. CatFile: Spec
08:28
14. Objects: Tree
05:25
17. WriteTree: Spec
19:53
19. LSTree: Spec
17:06
21. Objects: Commit
03:12
22. CommitTree: Spec
13:07
All
1 reviews
4.0
1 reviews
Reviews 1
∙
Average Rating 4.0
Edited
4
I listened up to about lecture 9-10. The end of lecture 9 is cut off. The video stops while the speaker hasn't finished talking. I thought the beginning of lecture 10 was cut off, but it started from the latter part of the content from lecture 9. Some parts were edited, so there's no overlap with the end of lecture 9, making it difficult to start right from the end of lecture 9. When explaining code, Go's unique syntax or Go's testing framework is used, but there is no explanation of that syntax or framework functions. The lecture introduction and early explanation say that users of other languages can also learn easily, but it doesn't seem that way. (I searched and found that Python uses similar syntax.) In lecture 6, actual execution was not shown, so I wondered if the lecture ended like that, but looking at lectures 9 and 10, it seems possible that the part where the test was actually run in lecture 6 was also cut off. ---------------------------------------------------------- Edited from the previous 1 star. The quick feedback and revisions were good. If I evaluate after completing the course, it was disappointing that the lecture proceeded in the order of writing test code for each function, then implementing the function. The video time for writing test code is longer than the actual implementation, but since the core of this lecture, as the title suggests, is to implement Git's internal functions directly, it would be more focused on the lecture's topic to show the pre-written test code before or after the function implementation lecture, indicating that this function requires these test cases. Because the implementation was relatively short, it felt more like studying how to write test cases. If you are just starting Git or know a little about it, I recommend taking this course after studying more. Although it teaches the basics of internal operations, it seems that a certain level of knowledge is needed for easier understanding. Thank you for your hard work.
Hello. I'm sorry to hear you are experiencing inconvenience. I apologize for having to make excuses. 1. While Go's grammar is briefly explained at the beginning of the lesson, as you mentioned, I am not explaining frameworks. The reason is that the method called testing is not actually a special method in Go. Rather than Go's specific testing methods, I wrote it using a commonly known BDD framework. Nevertheless, I think it's possible that the way I wrote the code was unfamiliar. 2. I'm truly sorry about the parts you mentioned being cut off. I'm not sure how that happened. It seems to have changed slightly from when it was uploaded in the past. I will revise it and inquire with the platform.
I checked, Seungnyeong-nim. For some reason, the latter part of lecture 6 was missing the implementation section. I have a record of uploading it, so its absence from the lecture is a bit puzzling. It has now been re-uploaded. As you mentioned, lectures 9 and 10 (now 10, 11) did end abruptly, but lecture 10 is intended to continue from the end of lecture 9. This part was created by dividing the section where the test is written first and then the specific implementation. Regardless, I apologize for the inconvenience caused by this oversight.
$77.00
Check out other courses by the instructor!
Explore other courses in the same field!