О чём этот курс — понимание ОС глазами Junior

Представьте: вы написали одну строчку — print("hello") — и на экране появилось hello. Кажется, что компьютер просто «сделал, что попросили». На самом деле между вашим кодом и буквами на экране произошла целая цепочка событий: кто-то решил, какой программе сейчас работать, кто-то нашёл нужный кусок памяти, кто-то передал текст на экран. Этим «кем-то» и занимается операционная система (ОС) — невидимый управляющий, который стоит между вашими программами и железом компьютера.

Этот курс — про то, как устроен и как работает этот управляющий. Простыми словами и по шагам мы разберём, что такое программа в момент запуска, как компьютер делает много дел «одновременно», откуда берётся и куда девается память, почему файлы открываются именно так, а не иначе. Мы не лезем в дебри исходного кода ядра — мы строим понятную картину мира, которая объясняет поведение реального софта: почему программа вдруг «упала», почему всё «тормозит», почему один и тот же скрипт где-то работает, а где-то нет. За референс берём Linux — он открытый, хорошо документирован и стоит на большинстве серверов, с которыми вы столкнётесь в работе.

Не пугайтесь, если сейчас не знаете, что такое терминал, и никогда не открывали командную строку. Курс начинается с самых азов, а если хочется потренироваться на терминале и файлах с нуля — есть отдельный вводный курс computing-basics (ссылка ниже). Сюда можно прийти буквально «с дивана».

К концу курса для вас станут привычными слова, которые сейчас, возможно, выглядят пугающе: системный вызов (syscall), процесс и поток, виртуальная память, планировщик, права доступа, файловый дескриптор. Пока просто запомните: всё это — части одной понятной картины, которую мы соберём вместе, кирпичик за кирпичиком.

Зачем Junior знать про ОС

Можно стать программистом и никогда не знать, что такое syscall. Pip установится, Docker запустится, Postgres ответит. Пока всё работает — хорошо. Но в реальной работе Junior регулярно сталкивается с ситуациями, где без понимания ОС вы беспомощны:

Типичные ситуации, где знание ОС критично

OOM Killer

Zombie процессы

High load average

Permission denied

Slow fsync

Deadlock

В каждом из этих случаев документация к фреймворку или языку программирования не поможет. Нужно понимать слой ниже — как ваш процесс взаимодействует с ядром, как ядро управляет ресурсами. Без этого вы не Junior+, который умеет дебажить, а Junior, который пишет тикет в DevOps и ждёт.

Второй момент — собеседования. Любой mid/senior-инженер на интервью спросит: «Что такое fork и чем отличается от exec?», «Что такое страничная память?», «Что показывает load average 5?». Это не для того, чтобы вас завалить — это для проверки, понимаете ли вы, на чём работает ваш код. Курс отвечает на все эти вопросы конкретно и без воды.

Что курс даёт, а что — нет

Курс задуман как широкая база. Мы не лезем в исходники ядра, не пишем драйверы, не оптимизируем планировщик CFS. Это работа Linux Kernel Engineer-ов, и таких в мире несколько тысяч. Junior эта глубина не нужна — она даже вредна, потому что вы потеряете месяцы и не разберётесь в чём-то одном.

Что внутри vs что снаружи курса

Inside

Outside

Процессы, потоки

CFS реализация

Virtual memory

Page replacement детали

strace, perf, /proc

Драйвер устройства

После курса вы сможете:

Объяснить, что делает каждая колонка ps -ef, top, vmstat.
Прочитать вывод strace и понять, где программа застряла.
Различать stack, heap, mmap, shared memory — и знать, когда что использовать.
Понимать, почему kill -9 иногда не убивает процесс.
Дебажить «странности»: zombies, OOM, slow I/O, deadlock — через /proc/[pid].
Читать dmesg после паники системы и понимать, что случилось.
Сделать осознанный выбор: процесс или поток, file I/O или mmap, ext4 или xfs.

Чем os-fundamentals отличается от linux-fundamentals

Это частый вопрос. Курсов с похожими названиями много, легко запутаться. Краткий ответ: linux-fundamentals про команды, os-fundamentals про модель.

Разделение между двумя курсами

linux-fundamentals

os-fundamentals

grep, awk, sed

strace, perf, ftrace

apt, dnf, brew

fork, exec, wait

chmod, ls -l

UID/GID, capabilities

Курсы дополняют друг друга. Идеальный порядок: сначала linux-fundamentals — научились свободно работать в shell, потом os-fundamentals — поняли, что внутри. На практике многие проходят их параллельно или возвращаются к linux-fundamentals по необходимости.

Что такое Linux: ядро, GNU и system calls Namespaces и cgroups — основа контейнеров

NOTE

Если у вас уже есть опыт работы в Linux на уровне «знаю основные команды и могу разобраться по man», смело начинайте с этого курса. Если же команда ps -ef | grep python | awk '{print $2}' кажется магией — сначала пройдите linux-fundamentals хотя бы наполовину.

Аудитория курса

Курс рассчитан на:

Junior Data Engineer и Junior Backend. Вы пишете на Python/Go/JS, ваш код деплоится на Linux-сервер. Вы хотите понимать, что происходит, когда ps -aux показывает 8 процессов вашего сервиса, а free -h пишет, что свободной памяти 200MB.
Студенты CS в начале пути. В университете «Операционные системы» — курс полугодовой и часто слишком теоретический. Этот курс — практическое дополнение: вы открываете терминал и видите всё своими глазами через /proc, strace, vmstat.
DevOps в начале карьеры. Вы настраиваете Docker, Kubernetes, CI/CD. Чтобы дебажить «pod падает с OOMKilled», «контейнер ест 100% CPU», «volume не монтируется» — нужно понимать ОС под Docker’ом.
Программисты, которые перешли в Linux из Windows/macOS. Вы умеете писать код, но man fork и страница /proc/sys/vm/overcommit_memory пока пугают. Курс закрывает gap.

Что от вас ожидается:

Базовое умение работать в командной строке (cd, ls, ps, grep, vim/nano).
Любой язык программирования — мы используем Python в примерах, но C-примеры тоже будут (с пояснениями).
Доступ к Linux: VM, WSL2, Docker-контейнер с --privileged — всё подойдёт. На macOS многие команды работают по-другому или отсутствуют (/proc нет!), поэтому без Linux-окружения курс делать сложно.

Формат курса

17 модулей, 50+ часов материала. Каждый модуль — 4-5 уроков. Каждый урок:

Теория с диаграммами. Чтобы было понятно, что происходит концептуально.
Реальные примеры с выводом команд. Не «приблизительно», а буквально copy-paste из терминала.
«Попробуй сам». Упражнение прямо сейчас: открыть терминал, выполнить, посмотреть.
Knowledge Check. Развёрнутый вопрос для самопроверки.
Quiz. 4-6 вопросов, разбираемых после урока.
Module Exam. В конце модуля — 6 deep вопросов на интеграцию темы.

Капstone-модуль (последний) — сборка мини-инструментов: свой ps из /proc, своя shell с pipes, мониторинг с alerts. Это закрепление всего, что вы изучили.

Реальный пример: что вы поймёте после курса

Вот вывод top на типичном сервере:

top - 14:23:08 up 47 days,  3:14,  1 user,  load average: 2.45, 1.82, 1.34
Tasks: 187 total,   2 running, 185 sleeping,   0 stopped,   0 zombie
%Cpu(s):  8.2 us,  3.1 sy,  0.0 ni, 80.5 id,  7.8 wa,  0.0 hi,  0.4 si,  0.0 st
MiB Mem :   7836.2 total,    412.1 free,   2840.5 used,   4583.6 buff/cache
MiB Swap:   2048.0 total,   1024.8 free,   1023.2 used.   4501.7 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 1234 postgres  20   0  2.3g   480m   12m S  12.3   6.1   8:42.13 postgres
 5678 root      20   0  120m    24m   8m  S   2.1   0.3   2:14.05 sshd
 9012 deploy    20   0   1.8g  890m  108m S   0.0  11.3 124:00.12 python

После курса вы прочитаете это так: «Up 47 дней, load average растёт (1.34 -> 2.45 за 15 минут), в основном CPU занят user-space (8.2%) и I/O wait (7.8%) — значит, кто-то напрягает диск. Из памяти 7.8 GB всего, свободно 400 MB, но 4.5 GB занято под page cache (buff/cache) — это нормально, ядро использует свободную RAM под кэш. Swap занят на 1 GB — какие-то страницы давно не использовались и были вытеснены. Python PID 9012 ест 890 MB RSS (резидентная память) при VSZ 1.8 GB — разница в основном за счёт mmap’ленных файлов и shared libs. Этот процесс почти не использует CPU прямо сейчас (0.0%) но за всё время использовал 124 минуты — значит, давно работает».

Всё это становится понятно после прохождения курса. Сейчас может казаться непонятным — и это нормально. К концу 14-го модуля каждая колонка top будет для вас как открытая книга.

Попробуй сам

Если у вас уже есть Linux под рукой, выполните эти команды — мы будем возвращаться к ним в течение всего курса:

# Сколько процессов сейчас в системе:
ps -e | wc -l

# Какие top-5 по памяти:
ps -eo pid,user,rss,cmd --sort=-rss | head -6

# Что происходит с моим shell прямо сейчас (PID, PPID, state):
ps -o pid,ppid,uid,stat,cmd $$

# Сколько syscalls делает простейший `ls`:
strace -c ls 2>&1 | tail -20

# Сколько памяти в системе:
free -h

# Load average:
uptime

Записать любые цифры и наблюдения. К концу курса вы вернётесь к этим командам и увидите всё по-другому.

Как создавался курс

Курс создан при участии Claude (Anthropic) как соавтора: ИИ помогал писать материалы, структурировать темы, генерировать примеры кода и диаграммы. Каждая глава проходила ручную сверку с первоисточниками — спецификациями, документацией, исходным кодом рассматриваемых систем — но гарантировать 100% точность невозможно.

Если вы заметили неточность, опечатку или хотите предложить улучшение — напишите в Telegram-группу курса. Это самый ценный вклад в курс, который вы можете сделать.

Углублённое изучение с Claude

Курс рассчитан на самостоятельное изучение, но любая теория быстрее ложится, если задавать вопросы. Рекомендую держать рядом браузерное расширение Claude (claude.com/download) — оно работает с контентом открытой страницы: выделяете кусок урока и спрашиваете напрямую.

Сценарии, которые особенно хорошо работают для углублённого погружения:

«Объясни проще» / «дай ещё один пример» — когда формулировка из урока не дошла с первого раза.
«Покажи, как это устроено на уровне кода / железа» — когда хочется спуститься на слой ниже того, что даёт урок.
«Как это связано с [другая тема курса]» — когда нужно увязать концепцию с тем, что было раньше.
«У меня в проекте стек X — как применить?» — когда хочется примерить материал на свой реальный кейс.

Это не замена курсу, а способ ускорить интеграцию материала в вашу картину мира. Если что-то из ответов Claude расходится с уроком — присылайте в Telegram-группу, курс будет уточнён.

Нашли ошибку?

Если заметили неточность, опечатку или хотите предложить улучшение:

Telegram-группа курса

Обсуждение, вопросы, предложения

Telegram-канал

Подписывайтесь, чтобы узнавать об обновлениях и новых курсах:

@levoely_channel

Новости, обновления, новые курсы

Проверка знанийKnowledge check

Junior говорит: 'Я изучаю Python и Django, зачем мне знать про syscalls и виртуальную память? Это работа DevOps'

ОтветAnswer

Это распространённое заблуждение. Программист на Python пишет ВСЁ через системные вызовы -- просто не видит этого напрямую. Когда вы делаете 'open(file)' в Python, под капотом происходит syscall openat(). Когда вы запускаете subprocess.Popen() -- это fork() + execve(). Когда Django читает запрос из сокета -- recvfrom(). Когда Postgres делает commit -- fsync(). Понимание этого слоя нужно ровно тогда, когда что-то идёт не так. Примеры реальных проблем, с которыми сталкивается Junior уже на первой работе: (1) Django-процесс убивается OOM Killer на проде -- надо понимать почему и как смотреть в dmesg; (2) сервис висит на open() -- надо знать про blocking I/O и timeouts; (3) Docker-контейнер съел всю память -- надо знать про memory cgroups и RSS; (4) приложение делает sync в файл -- задержки выросли с 1ms до 100ms -- надо понимать fsync и write barrier. DevOps настраивает инфраструктуру, но дебажит код в первую очередь сам программист. И если вы не понимаете, что между вашим кодом и железом есть слой ОС со своими правилами -- вы либо не сможете дебажить, либо будете годами писать тикеты в DevOps. Лучше потратить 50 часов на этот курс и стать самостоятельным.