강의

멘토링

커뮤니티

Programming

/

Programming Tool/Software

Learn Git Internals by Building It Yourself

Learn and create Git actions yourself, the de facto standard for version control tools!

(4.0) 1 reviews

63 learners

Level Basic

Course period Unlimited

  • Jayce
Git
Git
internals
internals
Go
Go
system-programming
system-programming
Git
Git
internals
internals
Go
Go
system-programming
system-programming

What you will gain after the course

  • Git Internals

  • System Programming

Learn Git Internals by Building Your Own 📖

Build From Scratch! Build Your Own Git!

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.


Course Target Audience/Course Purpose 🙆‍♀️

Types of students considered by knowledge sharers

  • Anyone who wants to explore the under the hood of frequently used technologies
  • People who want to experience deep exploration in engineering
  • Anyone who wants to understand more precisely how Git works

Students' Concerns & Solutions

  • 🥲 How do you delve deeper into the skills required in an interview?
  • 🧐 I've only used Git, but I'm curious about how it works?
  • 🤨 Is there anything suitable for a system programming project?

Changes in students after attending the lecture

  • A developer with experience exploring the deep engineering principles of very popular tools.
  • Developers who have worked on system programming projects in frequently used languages
  • A developer who knows exactly how Git works and can use it

Lecture Features ✨

  • The course will provide hands-on exercises that demonstrate the inner workings of Git.
  • The lecture exercises are conducted in the Go language, but only use syntax that can be easily replaced in any language.
  • It also includes an explanation of the Go syntax used.
  • You can learn system programming and gain meaningful system programming practice.

What you'll learn 📚

  • Intro: This course provides a brief explanation of basic Go, functions for system programming, and an overview of the course to make it easier to follow along.
  • Git Internals: Develop Git's internal components one by one and study their specific operations.
  • Git Overview: We'll explore the specific steps and internal components used to implement Git's core operations of version control, branching, and remote operations.

Expected Questions Q&A 💬

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.


Things to note before taking the course 📢

Learning Materials

  • Lecture materials PDF for theoretical study
  • Github Repository where you can check the result code

Player Knowledge and Precautions

  • Ability to write programs of more than 500 characters in a language of your choice

Recommended for
these people

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

Hello
This is

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. 🙂

Curriculum

All

36 lectures ∙ (6hr 46min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

All

1 reviews

4.0

1 reviews

  • devgmonk6353님의 프로필 이미지
    devgmonk6353

    Reviews 1

    Average Rating 4.0

    Edited

    4

    100% enrolled

    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.

    • byjayce
      Instructor

      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.

    • byjayce
      Instructor

      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

Jayce's other courses

Check out other courses by the instructor!

Similar courses

Explore other courses in the same field!