Computer Science: карта курса и зачем нужна большая картина

Можно годами писать работающий код и ни разу не задуматься, что происходит между нажатием клавиши и появлением буквы на экране. Абстракции для того и придуманы, чтобы об этом не думать. Проблема в том, что рано или поздно каждая абстракция протекает — и тогда человек без большой картины оказывается беспомощен.

Знакомые истории. 0.1 + 0.2 в JavaScript даёт 0.30000000000000004, и биллинг расходится на копейку. Программа быстрая на ноутбуке становится в двадцать раз медленнее в проде, хотя код не менялся — просто данные перестали помещаться в кэш процессора. Запрос к API отвечает за 150 миллисекунд, и никакая оптимизация кода не помогает, потому что это скорость света между континентами, а не ваш алгоритм. Сайт «иногда не открывается», и причина — в кэше DNS, о существовании которого разработчик фронтенда не подозревал.

Во всех случаях сломалась не программа. Протекла абстракция — и обнажился слой, который она обещала спрятать. Computer science — это и есть карта всех этих слоёв. Не набор фактов для собеседования, а связная модель того, как из движения электронов в кремнии получается работающее приложение. Кто держит эту модель в голове, тот отлаживает причину; кто не держит — перезапускает сервис и надеется.

Этот трек — обзорный. Он не заменяет глубокие курсы по алгоритмам, структурам данных, операционным системам или базам данных — наоборот, он даёт костяк, на который эти курсы нанизываются. Задача обзора — показать всю башню сразу и объяснить, как соседние этажи держат друг друга.

Что такое computer science, если говорить строго

Первое заблуждение, которое стоит снять сразу: computer science — это не про компьютеры, как астрономия — не про телескопы. Компьютер — это инструмент, а не предмет науки. Классическая формулировка приписывается Эдсгеру Дейкстре, и она точна.

Предмет — вычисление и информация: что в принципе можно посчитать, какими шагами, за какое время и на какой памяти, как представить данные и как надёжно ими обмениваться. Три вопроса задают весь каркас дисциплины:

1. Что вообще вычислимо? Есть задачи, которые не решит никакой компьютер — ни сегодняшний, ни будущий, никогда. Это не про «пока не придумали», а про доказанный предел. Здесь живут машина Тьюринга и проблема остановки — статьи 01 и 15.
2. Как представить и обработать данные? Всё — числа, текст, картинки, звук, сама программа — в итоге становится битами. Как именно и почему так — статьи 02 и 03.
3. Насколько это дорого? Вычислимо не значит осуществимо. Задача может требовать миллиард лет или больше атомов, чем есть во Вселенной. Мера стоимости — сложность, статья 10.

Отсюда и определение, которым будем пользоваться дальше: computer science изучает автоматическую обработку информации — её пределы, её представление и её цену. Программирование — прикладная инженерия поверх этой науки, как строительство поверх сопромата.

Главная идея всей дисциплины — абстракция

Если из курса нужно унести одно слово, это слово — абстракция. Абстракция — это контракт: интерфейс, который что-то обещает, и реализация, которая прячется за ним. write(файл, данные) обещает «данные записаны» — и не говорит ни слова про диск, контроллер, кэш и файловую систему.

Вся история вычислительной техники — это башня таких контрактов, надстроенных друг над другом. Никто не проектирует процессор, думая об электронах; никто не пишет веб-приложение, думая о регистрах. Каждый слой позволяет забыть про нижний — и именно это делает возможной современную сложность. Один человек физически не удержит в голове путь от кванта до React; но каждый слой в отдельности — удержит.

Башня абстракций: от транзистора до приложения

Вот весь маршрут курса на одной картинке. Читается снизу вверх: физика внизу, пользователь наверху. Каждый слой опирается на нижний, прячет его сложность и предоставляет более удобный контракт следующему.

Пройдём её снизу вверх — это и есть логика всего трека.

Электроны → транзисторы. Внизу лежит физика: транзистор — крошечный переключатель, который пропускает или не пропускает ток под управлением другого сигнала. Всё, что умеет процессор, собрано из миллиардов таких переключателей. Мы принимаем это как данность и договариваемся: «ток есть» — это 1, «тока нет» — это 0. Так появляется бит — статьи 01, 02.

Биты → логика. Из битов и трёх операций — И, ИЛИ, НЕ — собираются логические вентили, а из вентилей — сумматоры, компараторы, ячейки памяти. Удивительный факт: всей арифметики и всей логики хватает три операции. Это булева алгебра, статья 04.

Логика → процессор. Миллионы вентилей, соединённых по схеме фон Неймана, дают процессор: регистры (сверхбыстрая память на несколько чисел), АЛУ (арифметико-логическое устройство) и цикл выборка → декодирование → исполнение. Процессор тупо повторяет этот цикл миллиарды раз в секунду — статья 05. Рядом — иерархия памяти: регистры, кэши L1/L2/L3, ОЗУ, диск, каждый следующий уровень больше и радикально медленнее (статья 06).

Процессор → код. Процессор понимает только машинный код — числа-инструкции. Люди пишут на языках высокого уровня, а компиляторы и интерпретаторы переводят их вниз, до инструкций конкретного набора команд (статья 07). Здесь абстракция «переносимость»: один и тот же Python работает на x86 и на ARM.

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

Внутри программы — данные и алгоритмы. Как разложить данные в памяти, чтобы операции были быстрыми, — это структуры данных. Как оценить стоимость обработки — алгоритмы и сложность. Как пережить выключение питания — хранение и базы данных.

ОС → сеть → веб. Одной машины мало. TCP/IP превращает ненадёжную физическую передачу в надёжный поток байтов между любыми двумя машинами (статья 11). Поверх него веб: DNS переводит имена в адреса, HTTP переносит запросы, браузер рисует ответ (статья 12). И сквозь все слои проходит безопасность — шифрование, аутентификация, границы доверия.

Наверху — приложение. То, что видит пользователь. За одной кнопкой «Купить» стоит вся башня — и именно поэтому финальная статья собирает её обратно в единую картину.

Один пример через все слои сразу

Абстракции проще почувствовать на сквозном примере. Что происходит, когда вы вводите example.com и жмёте Enter? Запрос проваливается вниз по башне, летит через полмира и поднимается обратно — и каждый слой делает ровно свою работу.

За этой скромной диаграммой скрыто всё: DNS — распределённая база данных на весь мир; «открой TCP» — рукопожатие из трёх пакетов и гарантия доставки поверх ненадёжной сети; каждый пакет внизу превращается процессором в инструкции над регистрами; «разбор HTML» — это парсер, дерево (структура данных) и алгоритмы раскладки. Одно действие пользователя — и задействована буквально каждая статья трека. Полный разбор этого пути — в статье 12.

Почему каждая абстракция протекает

Джоэл Спольски сформулировал закон дырявых абстракций: любая нетривиальная абстракция в той или иной степени протекает (The Law of Leaky Abstractions, 2002, joelonsoftware.com). Абстракция экономит внимание ровно до тех пор, пока всё идёт штатно. На границе — при нагрузке, ошибке, редком входе — нижний слой проступает наружу, и без знания этого слоя не разобраться.

Абстракция не бесплатна ещё и потому, что соседние уровни различаются по стоимости в тысячи и миллионы раз. Вот та же башня, но измеренная во времени доступа — числа из знаменитого списка Джеффа Дина «Latency numbers every programmer should know»:

Шкала логарифмическая: от регистра процессора до сетевого пакета через океан — девять порядков, в миллиард раз. Именно эта пропасть объясняет существование кэшей, буферов и CDN и делает «протекания» такими болезненными. Несколько канонических примеров, по одному на слой:

Отсюда практический принцип, к которому мы вернёмся в финале: знай свой слой и один соседний снизу. Не нужно держать в голове квантовую физику, чтобы писать на Python. Но нужно знать, что под числами лежит фиксированное число бит, под переменной — реальный адрес в памяти, а под await fetch() — сеть, которая может потерять пакет. Этого хватает, чтобы при протечке знать, куда спускаться.

Карта курса: восемнадцать статей

Трек читается сверху вниз — это восхождение по башне. Можно и точечно: если сломалась конкретная абстракция, идите сразу в её статью. Ниже — вся карта, сгруппированная по этажам.

Фундамент (00–01, 15). Что мы вообще называем вычислением и где его теоретический предел. Это рамка для всего остального: без неё «алгоритм» и «вычислимо» — пустые слова.

Данные в битах (02–03). Как число, текст, цвет и звук становятся нулями и единицами. Первый слой, где абстракция начинает протекать ощутимо (переполнение, IEEE 754, кодировки).

Железо (04–06). Как из логики собирается процессор и почему память устроена лестницей. Здесь живёт большая часть «необъяснимых» замедлений.

От кода к системе (07–08, 14). Как текст программы превращается в исполнение и как ОС даёт каждой программе иллюзию, что она на машине одна. Конкурентность стоит рядом, потому что иллюзий несколько одновременно.

Данные и алгоритмы (09–10, 13). Как разложить данные, как оценить стоимость обработки и как пережить выключение питания. Это мосты к глубоким трекам — структуры данных, алгоритмы, базы данных.

Связь и защита (11–12, 16). Как машины общаются, как из этого вырос веб и почему безопасность — сквозная тема, а не отдельный модуль.

Сборка (17). Финал собирает башню обратно и показывает, куда двигаться дальше по глубоким трекам.

Для кого этот трек и как его читать

Трек написан для того, кто уже что-то программирует (или учится) и чувствует нехватку системной картины — понимания, как оно всё на самом деле связано. Здесь не будет снисходительности: каждая тема объясняется с первых принципов, но всерьёз.

Три честные оговорки о границах курса:

• Это костяк, а не глубина. По каждому этажу на портале есть отдельный глубокий трек. Здесь — интуиция и связи; за деталями структур данных, алгоритмов, ОС, сетей, БД и математики идите в профильные треки. Ссылки расставлены по ходу.
• Каждый слой упрощён намеренно. Реальный процессор сложнее схемы фон Неймана, реальный TCP сложнее трёх пакетов. Упрощение — не обман, а первая рабочая модель, которую потом можно уточнять.
• Порядок — рекомендация, а не догма. Идеально читать снизу вверх, накапливая слои. Но если прямо сейчас горит конкретная протечка — начните с её статьи и спуститесь на этаж ниже.

Куда идти дальше вглубь после обзора — зависит от того, что тянет: теория вычислимости смыкается с лямбда-исчислением и математикой, системный этаж — с операционными системами, прикладной — с алгоритмами и структурами данных.

Мини-итог

• Computer science — наука о вычислении и информации: их пределах, представлении и цене; программирование стоит поверх неё.
• Всё построено как башня абстракций: транзистор → логика → процессор → память → код → ОС → сеть → веб → приложение. Каждый слой прячет нижний.
• Абстракции протекают: на границе — при нагрузке, ошибке, редком входе — нижний слой проступает, и разбирается только тот, кто знает свой этаж и один соседний снизу.
• Задача трека — дать эту карту целиком, а за глубиной каждого этажа отправить в профильные треки.

Источники и что почитать рядом. J. Nisan, N. Schocken, The Elements of Computing Systems (проект «Nand to Tetris», nand2tetris.org) — та же башня, собранная руками от вентиля до игры. J. Spolsky, The Law of Leaky Abstractions (2002). J. Dean, Latency numbers every programmer should know. A. Tanenbaum, Structured Computer Organization — классика про слои организации ЭВМ.

Что дальше

Начинаем восхождение с фундамента — с самого вопроса, вокруг которого выросла вся дисциплина: что вообще значит «вычислить» и почему у вычислимого есть строгий предел.

Что такое вычисление: от абака до Тьюринга и что значит «вычислимо»