Operating Systems

29h 33m 35s
English
Paid
September 21, 2024

The goal of this course is to help you understand the operating system, one of the most important pieces of software that almost all programs interact with.

Each module covers both the conceptual foundations and practical aspects for software engineers. You will write small programs and analyze: "How does the operating system do this? How do my knowledge explain the program's behavior?" By the end of each module, you will have a better understanding of operating systems and discover new ways to make programs more efficient and secure.

The core of the course consists of tasks on each topic. We recommend solving them independently, using ready-made solutions and additional explanations as needed. Although a textbook is not mandatory, we highly recommend "Operating Systems: Three Easy Pieces" ("OSTEP") as a supplement and indicate the chapters for reading alongside the tasks. We also suggest additional resources from the book "Computer Systems: A Programmer's Perspective" if you have a copy, as well as other useful materials.

Most of the topics we discuss are applicable to all operating systems, but where necessary, we will focus on Unix family operating systems, particularly through the lens of GNU/Linux, which we recommend running as a virtual machine if needed.

Important: We strongly recommend completing a course on computer systems or its equivalent before this course. Many subjects, such as basic computer architecture and knowledge of the C language, are considered fundamental.

Watch Online Operating Systems

Join premium to watch
Go to premium
# Title Duration
1 001 CPU timing 55:07
2 002 Stack overflow 42:13
3 003 Byte write 22:47
4 004 An introduction to operating systems exploring syscalls as the interface 01:22:44
5 005 What happens during a context switch 07:28
6 006 Learning how to better use man pages 09:01
7 007 A brief introduction to strace and ltrace 17:04
8 008 The motivation for address space layout randomization 04:42
9 009 What is POSIX compliance 05:06
10 010 What exactly is the kernel 04:20
11 011 What exactly is a syscall and how is it not a C stdlib function 06:20
12 012 Why time-sharing operating systems were such a big deal 05:47
13 013 Pre-emptive multitasking and the timer interrupt 06:49
14 014 What is the stack (simple explanation) 05:44
15 015 The early history of Unix 07:35
16 016 A brief overview of the flavors of Unix (ie why your grep may be different to mine) 12:40
17 017 What is the stack (detailed explanation) 16:22
18 018 Signalbox 33:31
19 019 Signal logger 01:09:07
20 020 Custom shell basic execution 57:33
21 021 Custom shell pipes 01:06:30
22 022 Custom shell job control 01:39:47
23 023 Exploring the process lifecycle 01:16:20
24 024 Pipelines dont execute sequentially 04:48
25 025 Fork details COW and vfork 10:05
26 026 What exactly is a process 03:49
27 027 Details of using pipes.mp4 11:09
28 028 Exploring processes by considering ps output 17:43
29 029 What is a signal 12:20
30 030 Understanding process groups and sessions 13:15
31 031 IO multiplexing select poll epoll and kqueue 10:48
32 032 Is everything a file in Unix 22:07
33 033 Brief overview of the process lifecycle 13:02
34 034 Foreground and background process groups 05:00
35 035 Internal representations of a process in Unix V6 and Linux 21:55
36 036 Threaded counter 18:10
37 037 Multi-threaded mergesort 58:25
38 038 Multi-threaded fizzbuzz 25:18
39 039 Ring buffer 01:09:22
40 040 The motivation for threads contrasted with IO multiplexing 38:12
41 041 What is a good scheduling policy 54:49
42 042 Understanding race conditions 14:45
43 043 Starting and waiting on POSIX threads 04:40
44 044 Processes threads and lightweight threads 18:23
45 045 Basic mmap 17:40
46 046 Shared memory stream 54:05
47 047 Custom malloc 01:26:52
48 048 The historical context for todays virtual memory system 38:20
49 049 What is swap memory and is it a good idea 11:29
50 050 The basic idea behind paging 02:53
51 051 Copy-on-write zero-on-demand and other virtual memory tricks 12:42
52 052 The motivation for multi-level page tables 18:28
53 053 An overview of the mmap system call 24:01
54 054 Why you probably shouldnt use the default 4KiB page size 11:28
55 055 A detailed view of Intels multi-level page tables 13:30
56 056 Custom ls 36:40
57 057 Mystery file 22:13
58 058 Custom file system 01:01:32
59 059 Whats the big idea behind file systems 06:05
60 060 Some virtual files and file systems 08:19
61 061 Sketching out a basic file system design 23:41
62 062 What is an inode 10:07
63 063 Container chroot 28:56
64 064 Container namespaces 01:02:00
65 065 Container cgroups 32:36
66 066 Container extras 27:16

Similar courses to Operating Systems

Supercharged Code Editing with Vim and Neovim

Supercharged Code Editing with Vim and Neovim

Duration 2 hours 55 minutes 8 seconds
Getting Started: Microservices Architecture

Getting Started: Microservices Architecture

Duration 5 hours 21 minutes 13 seconds
Shift Nudge – Interface Design Course (PRO packet)

Shift Nudge – Interface Design Course (PRO packet)

Duration 105 hours 34 minutes 18 seconds
Great Thinkers, Great Theorems

Great Thinkers, Great Theorems

Duration 12 hours 14 minutes 35 seconds
Programming: Beyond the Basics

Programming: Beyond the Basics

Duration 11 hours 14 minutes 57 seconds
Python for Financial Analysis and Algorithmic Trading

Python for Financial Analysis and Algorithmic Trading

Duration 16 hours 54 minutes 20 seconds
DNS course for developers

DNS course for developers

Duration 2 hours 44 minutes 2 seconds