English | MP4 | AVC 3840×2160 | AAC 44KHz 2ch | 66 Lessons (29h 34m) | 13.59 GB
The goal of this course is to help you understand the most important piece of software that almost every program interacts with: the operating system.
Each module will cover both conceptual foundations and practical considerations for software engineers. You will write short programs and ask yourself “How is the operating system making this happen? How does my conceptual understanding explain the behavior I’m seeing?” You should leave each one with a better overall understanding, and discover new ways to make your programs more efficient and secure
Operating Systems: Three Easy PiecesAt the core of this course are the sequences of problems for each topic. You should aim to solve each problem yourself, using the worked solutions and supplementary explainers as needed. While no textbook is strictly necessary for this course, we highly recommend Operating Systems: Three Easy Pieces (“OSTEP”) as a supplement, and suggest specific chapter to read in conjunction with each set of problems. We also suggest further resources from Computer Systems: A Programmer’s Perspective for those who already have a copy, as well as other relevant resources throughout.
Most of the topics we discuss will be broadly applicable to all operating systems, but where we need to get concrete we will focus on the Unix family of operating systems, and ultimately through the lens of GNU/Linux operating system, which we encourage you to run, if needed, as a virtual machine.We chose this operating system because of its popularity, and the availability of its entire source code. This isn’t a “Linux Course”, and most problems could be done on other operating systems, with some specific exceptions like those relating to containers (a Linux-specific concept). The same general principles tend to apply although specific interfaces can vary dramatically. No knowledge of Linux is required to take this course.
Important note: we strongly recommend that you complete most of Computer Systems or an equivalent course before this one. Many topics such as basic computer architecture and C familiarity are taken as assumed knowledge. You are of course welcome to try this course and cherry pick topics from Computer Systems to fill in gaps as you go. A number of problems will be most straightforward to complete in a compiled “systems” language such as C, C++ or Rust, although you are welcome to attempt them in any language.
Table of Contents
1 CPU timing
2 Stack overflow
3 Byte write
4 An introduction to operating systems exploring syscalls as the interface
5 What happens during a context switch
6 Learning how to better use man pages
7 A brief introduction to strace and ltrace
8 The motivation for address space layout randomization
9 What is POSIX compliance
10 What exactly is the kernel
11 What exactly is a syscall and how is it not a C stdlib function
12 Why time-sharing operating systems were such a big deal
13 Pre-emptive multitasking and the timer interrupt
14 What is the stack (simple explanation)
15 The early history of Unix
16 A brief overview of the flavors of Unix (ie why your grep may be different to mine)
17 What is the stack (detailed explanation)
18 Signalbox
19 Signal logger
20 Custom shell basic execution
21 Custom shell pipes
22 Custom shell job control
23 Exploring the process lifecycle
24 Pipelines dont execute sequentially
25 Fork details COW and vfork
26 What exactly is a process
27 Details of using pipes
28 Exploring processes by considering ps output
29 What is a signal
30 Understanding process groups and sessions
31 IO multiplexing select poll epoll and kqueue
32 Is everything a file in Unix
33 Brief overview of the process lifecycle
34 Foreground and background process groups
35 Internal representations of a process in Unix V6 and Linux
36 Threaded counter
37 Multi-threaded mergesort
38 Multi-threaded fizzbuzz
39 Ring buffer
40 The motivation for threads contrasted with IO multiplexing
41 What is a good scheduling policy
42 Understanding race conditions
43 Starting and waiting on POSIX threads
44 Processes threads and lightweight threads
45 Basic mmap
46 Shared memory stream
47 Custom malloc
48 The historical context for todays virtual memory system
49 What is swap memory and is it a good idea
50 The basic idea behind paging
51 Copy-on-write zero-on-demand and other virtual memory tricks
52 The motivation for multi-level page tables
53 An overview of the mmap system call
54 Why you probably shouldnt use the default 4KiB page size
55 A detailed view of Intels multi-level page tables
56 Custom ls
57 Mystery file
58 Custom file system
59 Whats the big idea behind file systems
60 Some virtual files and file systems
61 Sketching out a basic file system design
62 What is an inode
63 Container chroot
64 Container namespaces
65 Container cgroups
66 Container extras
Resolve the captcha to access the links!