CF

Operating Systems

29h 33m 35s
English
Paid

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.

About the Author: Oz Nova (CS Primer)

Oz Nova (CS Primer) thumbnail

Oz Nova is the founder of CS Primer (csprimer.com) and a co-founder of Bradfield School of Computer Science — an unusually rigorous CS-fundamentals education brand aimed at self-taught engineers filling in the formal computer-science foundations they didn't get from a four-year degree. The CS Primer course catalog goes deeper into the fundamentals than essentially any other paid online platform.

The course catalog covers compilers and language design, computer networks (from sockets through application protocols), distributed systems, computer architecture, operating systems, databases at the storage-engine level, and the algorithms / data-structures material taught at the level of a serious CS undergraduate course rather than an interview-prep cheat sheet.

The CourseFlix listing under this source carries 7 CS Primer courses spanning that range. Material is paid; CS Primer runs on per-course or membership pricing on the original platform. Courses are aimed at working software engineers ready to fill the foundational CS gaps that compound across a career.

Watch Online 66 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 66 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 001 CPU timing
All Course Lessons (66)
#Lesson TitleDurationAccess
1
001 CPU timing Demo
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
Unlock unlimited learning

Get instant access to all 65 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
The course strongly recommends completing a course on computer systems or an equivalent. A fundamental understanding of basic computer architecture and knowledge of the C programming language is considered essential for tackling the material covered in this course.
What practical skills will I gain from this course?
Throughout the course, students will engage in writing small programs to analyze operating system functions. Key skills include creating a custom shell with job control, understanding IO multiplexing techniques like select, poll, epoll, and kqueue, implementing multi-threaded applications, and constructing a custom file system. These tasks will help deepen understanding of operating systems and enhance programming efficiency and security.
Who is the target audience for this course?
This course is designed for software engineers and computer science students who wish to gain a deeper understanding of operating systems. It is suitable for those interested in the conceptual foundations and practical aspects of operating systems, particularly within Unix-like environments.
How does this course compare in depth and scope to similar courses?
The course offers a detailed exploration of both conceptual and practical aspects of operating systems across 66 lessons. It covers topics from CPU timing and stack overflow to advanced concepts like multi-level page tables and custom file systems. This makes it suitable for in-depth learning, unlike some introductory courses that might offer only a high-level overview.
What specific tools or platforms does this course focus on?
While most discussed topics apply to all operating systems, the course specifically focuses on Unix family operating systems, particularly through the GNU/Linux lens. Students are recommended to run GNU/Linux as a virtual machine if needed. Key tools covered include strace, ltrace, and POSIX threads.
What topics are not covered in this course?
The course does not cover topics outside the realm of operating systems, such as application-specific programming, web development, or network security. It maintains a focus on operating system concepts like process management, memory management, and file systems, leaving out broader computer science topics.
How much time should I expect to commit to this course?
While the course description does not specify a total runtime, the extensive list of 66 lessons indicates a significant time commitment. Students should be prepared to engage deeply with the material, including independent problem-solving and supplementary reading from recommended texts like 'Operating Systems: Three Easy Pieces'.