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

Бит — атом информации

Бит (bit, сокращение от binary digit — «двоичная цифра») — это наименьшая порция информации: либо 0, либо 1. Физически бит может быть чем угодно, что имеет два устойчивых состояния:

• ячейка микросхемы памяти: заряжена / не заряжена;
• участок жёсткого диска: намагничен туда / намагничен сюда;
• импульс в оптоволокне: есть свет / нет света;
• выключатель на стене: включён / выключен.

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

Байт — восемь бит вместе

Одним битом можно ответить только «да/нет» — этого мало. Поэтому биты давно договорились группировать по восемь: такая группа называется байт. Каждый бит в байте имеет свой «вес» — степень двойки: 128, 64, 32, 16, 8, 4, 2, 1. Значение байта — сумма весов включённых битов.

Восемь бит дают 2⁸ = 256 комбинаций: байт хранит число от 0 до 255. Этого хватает, чтобы закодировать одну букву, один оттенок цвета или одну ноту. Всё, что больше, собирается из многих байтов: число побольше — из 4 или 8 байтов, буква эмодзи — из 4 байтов, фотография — из миллионов байтов.

Килобайты, мегабайты, гигабайты

Тонкость: в информатике приставки иногда считают степенями двойки (1 КиБ = 1024 байта), а иногда десятками (1 КБ = 1000 байт). Из-за этого «диск на 1 ТБ» система показывает как «931 ГБ» — никто ничего не украл, просто считают по-разному.

Адресное пространство: у каждого байта есть номер

Байтов в компьютере миллиарды. Как найти нужный? Каждому байту присвоен адрес — порядковый номер, как номер квартиры в гигантском доме. Первый байт имеет адрес 0, второй — 1, и так далее. Совокупность всех адресов называется адресным пространством.

• «Записать число 65 по адресу 1000» — процессор знает точно, куда идти.
• «Прочитать то, что лежит по адресу 1000» — получит обратно 65.

Размер адреса ограничивает, сколько памяти вообще можно пронумеровать. Если адрес 32-битный, разных адресов существует 2³² ≈ 4,3 миллиарда — именно поэтому старые 32-битные компьютеры не могли использовать больше ~4 ГБ памяти: не хватало номеров для квартир. Сами «квартиры» (байты) физически есть, а пронумеровать их нечем. Современные 64-битные адреса дают 2⁶⁴ адресов — это около 18 миллиардов миллиардов, больше, чем памяти на всех компьютерах мира вместе взятых.

Оперативная память (ОЗУ / RAM)

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

• Быстрая. Чтение любого байта занимает десятки наносекунд. Для сравнения: чтение с SSD — в тысячу раз дольше, со старого жёсткого диска — в сто тысяч раз дольше.
• Произвольный доступ. RAM расшифровывается как Random Access Memory — «память с произвольным доступом»: ячейка № 5 000 000 читается так же быстро, как ячейка № 3. Это как книга, которую можно открыть сразу на любой странице, а не кассета, которую надо перематывать.
• Летучая. Ячейки ОЗУ держат данные, только пока есть питание. Выключил компьютер — всё стёрлось. Поэтому несохранённая работа пропадает при сбое, и поэтому существует диск.

Полезная аналогия: ОЗУ — это твой рабочий стол, а диск — шкаф с папками. Работаешь ты на столе (быстро, всё под рукой), а хранишь в шкафу (вместительно и надёжно). Когда говорят «у ноутбука 16 ГБ памяти», имеют в виду 16 гигабайт ОЗУ — 16 миллиардов пронумерованных байт на «столе».

Процессор (CPU, центральный процессор) — это работник, который сидит перед «домом» памяти и выполняет инструкции одну за другой. Поразительно, но список его умений крошечный. Вот почти всё, что он умеет:

Всё. Игры, видео, браузеры, нейросети — гигантские цепочки из этих примитивов. Вычитание? Это сложение с отрицательным числом. Умножение? Многократное сложение (или хитрые сдвиги битов). Трёхмерная графика? Миллионы умножений координат. Любая сложность раскладывается на простые шаги.

Регистры — карманы процессора

Каждый раз бегать в память за числами долго: даже быстрая ОЗУ в сотни раз медленнее, чем сам процессор. Поэтому у процессора есть несколько десятков собственных ячеек прямо «внутри» — регистров. Доступ к регистру мгновенный: один такт. Это «карманы» работника: он загружает числа из памяти в регистры, считает с ними, а результат записывает обратно.

Регистры не одинаковые — у них разные роли:

Как два примитивных регистра — счётчик команд и флаги — превращаются в «если» и циклы? Разберём на живом примере. Программа должна сравнить числа 7 и 5 и записать большее в ячейку 302. Проследим по шагам, что происходит с регистрами:

Обрати внимание на шаги 3–4: инструкция «сравнить» сама ничего не решает — она лишь зажигает лампочки-флаги. А инструкция «перейти, если флаг зажжён» смотрит на лампочку и, если условие выполнено, подменяет счётчик команд — процессор продолжает выполнение с другого места программы (строки по адресам 62–64, где лежало «записать r2», просто пропускаются). Было бы 5 > 7 — флаг не зажёгся бы, переход не случился бы, и процессор пошёл бы дальше подряд. Так из «сравнить + перейти» строятся все if/else, а прыжок назад, к уже выполненному адресу, даёт циклы for и while — во всех языках программирования.

Цикл работы: прочитай — пойми — выполни

Процессор живёт в бесконечном цикле из трёх шагов (его называют fetch — decode — execute):

1. Прочитать из памяти инструкцию по адресу из счётчика команд.
2. Расшифровать её: что делать и с какими числами.
3. Выполнить — и перейти к следующей инструкции (обычно она лежит следом, а если была команда перехода — по указанному адресу).

Как выглядит программа для процессора

Задача: сложить числа из ячеек 100 и 101, результат положить в ячейку 102. В «человеческой» записи (такая запись называется ассемблером) программа выглядит так:

; r1, r2 — регистры; [100] — "содержимое ячейки по адресу 100"
ЗАГРУЗИТЬ  r1 ← [100]       ; прочитать первое число в регистр r1
ЗАГРУЗИТЬ  r2 ← [101]       ; прочитать второе число в регистр r2
СЛОЖИТЬ    r1 ← r1 + r2      ; сложить, результат в r1
ЗАПИСАТЬ   [102] ← r1       ; записать результат в память

Каждая строка — одна машинная инструкция, и в памяти она тоже хранится байтами! Скажем, инструкция «СЛОЖИТЬ r1, r2» может кодироваться байтом 01 и номерами регистров, «ЗАГРУЗИТЬ из памяти» — байтом 10 и так далее (таблица кодов у каждого процессора своя — она называется набором инструкций, или архитектурой: x86, ARM, RISC-V).

Программа — это данные, которые процессор читает и исполняет. Эту идею — хранимую в памяти программу — в 1945 году сформулировал Джон фон Нейман, и на ней стоит вся современная вычислительная техника. До неё машины «перепрограммировали» буквально переключением кабелей: новая задача — новая схема. А с хранимой программой сменить задачу компьютера — это просто записать в память другие байты. Именно поэтому один и тот же ноутбук утром — игровая приставка, днём — «печатная машинка», а вечером — кинотеатр.

Когда данные «переползают» на инструкции: переполнение буфера

Раз программа и данные живут в одной памяти, возможна неприятность: данные могут затопить соседние ячейки. Разберём пример по косточкам. Программа выделила под имя пользователя 16 ячеек (адреса 200–215), а сразу за ними, с адреса 216, лежит кусок её собственного кода. Вот снимок памяти до ввода:

Пользователь вводит «имя» длиной 50 символов, а программа забыла проверить длину и просто пишет символы подряд, начиная с адреса 200. Буква «A» в ASCII — байт 41. Что окажется в памяти после ввода 50 букв «A»?

Это и есть переполнение буфера (buffer overflow): данные вылезли за границу отведённого места и затопили соседние ячейки. Что будет дальше? Дойдя до адреса 216, процессор прочитает 41 41 41 как инструкцию. Если такой команды нет — процессор «споткнётся», программа упадёт (это лучший случай: просто сбой). А теперь самое неприятное: что, если ввод подобрать не случайно? Злоумышленник вводит «имя», чьи байты с адреса 216 складываются в осмысленные инструкции — например, 10 01 64, «загрузи пароль», «отправь по сети». Программа, сама того не желая, начинает выполнять чужой код. Так работало большинство вирусных атак прошлых лет — от червя Morris (1988) до эпидемий 2000-х.

Как защищаются современные компьютеры:

• Проверка длины ввода — обязанность программиста: «места 16 байт? берём не больше 16»;
• Бит NX — процессор и ОС помечают области памяти «данные, выполнять запрещено»: байты имени физически не могут стать инструкциями;
• ASLR — при каждом запуске ОС перемешивает адреса, и атакующий не знает, где что лежит;
• Изоляция процессов — даже захваченная программа не дотянется до чужой памяти (подробнее — глава 5).

Частота и многоядерность

Скорость процессора измеряют в гигагерцах: 3 ГГц — примерно 3 миллиарда тактов в секунду. Пока ты моргаешь (около трети секунды), процессор успевает выполнить порядка миллиарда операций. Поэтому «медленный» компьютер — всё равно фантастически быстрый счётчик. Кроме того, в одном корпусе сегодня живёт несколько процессоров — ядер: 4, 8, 16. Каждое ядро выполняет свой поток инструкций, и программы делят между ними работу.

Из глав 1–2 компьютер выглядит замкнутым мирком: процессор перекладывает байты в памяти. Как этот мирок связан с экраном, клавиатурой и диском? Ответ — в красивом трюке, который называется ввод-вывод, отображённый на память (memory-mapped I/O).

Идея: устройства притворяются памятью

Некоторые адреса адресного пространства ведут не в обычную память. Они подключены к устройствам. Записал байт по такому «особому» адресу — он уехал не в ячейку ОЗУ, а на монитор, на диск или в сетевую карту. Прочитал особый адрес — получил данные от клавиатуры или мыши. Для процессора всё единообразно: те же команды «записать» и «прочитать», что и для памяти.

• Хочешь показать картинку? Запиши цвета пикселей по адресам видеопамяти.
• Хочешь сохранить файл? Запиши контроллеру диска команду «запиши эти байты в такой-то сектор».
• Хочешь узнать, какая клавиша нажата? Прочитай ячейку контроллера клавиатуры.

Новое слово — контроллер. Это маленький специализированный компьютер внутри самого устройства: своя простенькая микросхема-процессор и своя память. У каждой железки есть такой «посредник»: у диска — контроллер диска, у клавиатуры — контроллер клавиатуры. Зачем он нужен? Главный процессор не умеет (и не хочет уметь) крутить мотором диска, подавать напряжение на нужную дорожку или опрашивать кнопки по очереди. Он просто пишет контроллеру в «особые ячейки» команду вроде «прочитай сектор 12345», а контроллер уже сам управляет физикой устройства и складывает результат в известные ячейки. Договорённость о том, какие команды понимает контроллер, — это и есть то, что потом знает драйвер.

Как это работает с монитором

Экран — это сетка пикселей. Цвет каждого пикселя кодируется тремя числами: сколько красного, зелёного и синего (система RGB), обычно по байту на каждый — от 0 до 255. Область, где лежат цвета всех пикселей, называется видеопамятью (или кадровым буфером). Монитор десятки раз в секунду «перечитывает» её и светит пикселями соответствующих цветов.

; упрощённо, как на простых компьютерах:
ЗАПИСАТЬ [видеопамять + 0] ← 255   ; первый пиксель: красного — максимум
ЗАПИСАТЬ [видеопамять + 1] ← 0     ; зелёного — ноль
ЗАПИСАТЬ [видеопамять + 2] ← 0     ; синего — ноль. Итог: ярко-красный пиксель!

«Нарисовать картинку» для программы — это буквально «записать миллионы чисел в видеопамять». Игра с бегающим персонажем каждый кадр заново вычисляет и записывает все пиксели — 60 и более раз в секунду. Мигающий курсор в терминале — программа, которая раз в полсекунды переписывает один прямоугольник пикселей туда-сюда.

Считаем видеопамять

Экран 1920 × 1080 пикселей — это 2 073 600 пикселей. По 3 байта на пиксель — около 6,2 МБ на один кадр. В секунду при 60 кадрах видеокарта перезаписывает ~370 МБ. А если разрешение 4K и цвет точнее — ещё больше. Теперь понятно, почему видеокарты оснащают собственной быстрой памятью в несколько гигабайт.

С диском, клавиатурой и сетью — так же

• Диск. Программа пишет в ячейки контроллера диска команду и номер блока, а затем либо передаёт байты (запись), либо забирает их (чтение).
• Клавиатура. При нажатии клавиши контроллер кладёт её код в известную ячейку, и процессор (обычно по сигналу «прерывания» — «эй, посмотри сюда!») читает его.
• Сеть. Записал байты в буфер сетевой карты — они улетели в интернет; пришёл ответ — карта сложила его в буфер и сообщила процессору.
• Звук. Числа в буфере звуковой карты превращаются в колебания динамика — сотни тысяч значений в секунду.

Диск и память: как гигабайты едут без участия процессора

Посмотрим на связку «диск ↔ память» внимательнее — она понадобится в главе 4. Наивный способ прочитать файл: процессор в цикле читает по байту из ячеек контроллера диска и записывает в ОЗУ. Для фильма в 2 ГБ это миллиарды инструкций — процессор больше ничего не успеет. Поэтому придумали DMA (direct memory access — «прямой доступ к памяти»):

1. Процессор пишет контроллеру диска в «особые» ячейки задание: «прочитай блоки с такого-то по такой-то и положи байты в ОЗУ начиная с адреса 5 000 000».
2. Дальше контроллер сам, без процессора, переливает данные с диска прямо в оперативную память.
3. Закончив, контроллер подаёт процессору прерывание: «готово, забирай».

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

Оперативная память — «рабочий стол»: быстро, но всё пропадает при выключении. Долговременное хранение — задача диска. Диск медленнее ОЗУ, зато помнит данные без питания и вмещает сотни гигабайт и терабайты. Физически это либо магнитные пластины (HDD — жёсткий диск, где биты — намагниченные участки), либо флеш-память (SSD и флешки, где биты — заряды в ловушках ячеек). Но как бы ни был устроен диск, логика поверх него одна и та же.

Файл — это просто цепочка байтов

Файл — это последовательность байтов, хранящаяся на диске под одним именем. Всё. Фотография — файл. Песня — файл. Программа — файл. Это пособие — файл. С точки зрения диска они ничем не отличаются: просто наборы нулей и единиц разной длины.

• кот.jpg размером 3 МБ — цепочка из трёх миллионов байтов;
• заметки.txt размером 100 байт — цепочка из ста байтов;
• фильм на 2 ГБ — цепочка из двух миллиардов байтов.

Чтобы открыть файл, операционная система читает его байты с диска в оперативную память (помнишь про «стол» и «шкаф»?) — и дальше с этими байтами работает программа.

Файловая система: имена и папки хранятся отдельно

Хитрость в том, что содержимое файла и его имя хранятся в разных местах. На диске есть служебная область — файловая система (NTFS, APFS, ext4…). Это каталог, как в библиотеке: карточка говорит, как файл называется, в какой папке лежит, какого он размера, когда изменён — и в каких участках диска записаны его байты. Папка, кстати, тоже файл особого вида: просто список «какие карточки в меня входят».

Из этого следуют три важных факта:

1. Переименование и перемещение мгновенны. Переименовал файл или переложил в другую папку — сами байты не сдвинулись ни на бит: изменилась только запись в каталоге. А вот копирование на флешку долгое — там байты реально переписываются.
2. Удаление не стирает байты. «Удалить файл» обычно значит «вычеркнуть карточку из каталога и пометить место свободным». Байты остаются на месте, пока их не перезапишут новые данные. Поэтому удалённые файлы часто можно восстановить — и поэтому секретные данные затирают специальными программами.
3. Путь — это цепочка папок. Место файла в каталоге записывается путём: /home/anya/документы/реферат.docx в Linux или C:\Users\Anya\Documents\… в Windows. Важно понимать: путь существует только в каталоге — это «логический адрес» для человека. На самом диске байты файла могут лежать где угодно и вразброс: диск делён на блоки (обычно по 4 КБ), и файловая система размещает блоки файла в первых свободных местах. Соседние папки «в каталоге» вовсе не обязаны быть соседями «на железе».

Представим диск как сетку пронумерованных блоков (упрощённо — 32 блока по 4 КБ). Подсветим, где реально лежат байты четырёх файлов:

Обрати внимание: «реферат» и «кот» лежат в разных папках каталога, а их блоки на диске — рядом (5, 6, 7). Зато «трек» из одной папки размазан по двум далёким участкам (10–15 и 26–27). Папки — это порядок в картотеке, а не на «полках». Кстати, отсюда понятно слово «фрагментация»: когда блоки файла разбросаны, механическому диску приходится дольше двигать головкой, и чтение медленнеет (SSD это почти не волнует — у него нет движущихся частей).

Расширение ≠ содержимое

Окончание имени (.jpg, .txt, .exe) — просто подсказка человеку и системе, какой программой файл обычно открывают. Переименуй фотографию из кот.jpg в кот.txt — байты внутри не изменятся ни на бит! Просто двойной клик теперь откроет её «Блокнотом», и ты увидишь кашу из символов. Фотография от этого не «испортилась»: верни расширение — всё как было.

Как же программы угадывают настоящий тип файла? Многие форматы начинаются с магических байтов — подписи в начале файла. Например, PNG всегда начинается с байтов 89 50 4E 47 («.PNG»), PDF — с символов %PDF, ZIP — с PK. Программа может заглянуть в первые байты и понять, что перед ней, независимо от расширения.

Архивы: как файлы ужимаются

Форматы .zip, .rar, .7z делают две вещи сразу: складывают много файлов в один контейнер (с именами и папками — маленькая файловая система внутри файла!) и сжимают — записывают те же данные меньшим числом байт. Как ужать текст, не потеряв ни буквы? Двумя простыми идеями, на которых стоят почти все архиваторы:

• Повторы подряд. «AAAAAAAAAA» короче записать как «10 раз A» — это принцип RLE (кодирование длин серий). Бежит сто нулей? Записываем «100 нулей».
• Словарь частых кусков. Представь книгу, где слово «князь» встречается 5000 раз: 6 букв ≈ 12 байт каждый раз, итого 60 000 байт. Хитрость: один раз занести «князь» в словарь под номером, скажем, 257 — и дальше в тексте писать короткую ссылку «слово №257» (2 байта). Экономия десятки тысяч байт! Реальные алгоритмы (семейство Лемпеля—Зива, внутри ZIP и gzip) делают то же самое, но сами находят повторяющиеся куски байтов и строят словарь на лету.

Важно: сжатие в архивах без потерь — после распаковки файл возвращается бит в бит. А вот сильно сжать получается только то, где есть повторы и закономерности: текст и таблицы жмутся в разы, а уже сжатые JPEG и MP3 — почти нет (закономерности оттуда уже выжаты). Поэтому архив фотографий «весит» столько же, сколько сами фотографии.

В главе 2 мы узнали: процессор выполняет машинные инструкции. Где они хранятся, когда компьютер выключен? В файлах. Исполняемый файл (.exe в Windows, обычно без расширения в Linux и macOS) — это файл, чьи байты кодируют последовательность машинных инструкций плюс служебную информацию: где у программы точка входа, какие библиотеки нужны.

Что происходит при запуске программы

1. Операционная система читает исполняемый файл с диска в оперативную память.
2. Находит в нём точку входа — адрес первой инструкции.
3. Создаёт процесс: выделяет программе участок памяти и говорит процессору «выполняй инструкции с этого адреса».
4. Процессор начинает цикл «прочитай — пойми — выполни»: программа жива. Она пишет пиксели в видеопамять, читает клавиатуру, обращается к диску — всё через механизмы главы 3.

Итак: программа = данные, пока лежит на диске, и действие, когда процессор её выполняет. Запущенная копия программы называется процессом. Одна и та же программа может быть запущена десять раз — будет десять независимых процессов.

Как процессор успевает всё сразу

У тебя открыты браузер, мессенджер и музыка — а ядер всего несколько. Фокус в том, что операционная система тысячи раз в секунду переключает процессор между процессами: чуть-чуть поработал один, сохранил его состояние, дал поработать следующему. Это называется многозадачность. Для человека всё идёт «одновременно», для процессора — строго по очереди, просто очень быстро.

Откуда берутся исполняемые файлы

Люди пишут программы на понятных языках — Python, C++, JavaScript. Процессор понимает только машинные инструкции, поэтому между человеком и машиной есть два пути перевода:

Забавный факт: интерпретатор Python — сам обычный исполняемый файл, написанный на C. Когда ты запускаешь Python-скрипт, процессор выполняет инструкции интерпретатора, а тот читает и исполняет твой код. Матрёшка!

Операционная система: изоляция и посредничество

Из глав 2–3 может сложиться впечатление, что программа делает с железом что хочет. На самом деле — нет: между программой и железом стоит операционная система (Windows, macOS, Linux, Android, iOS), и она стоит там нарочно, по двум причинам:

• Безопасность. Помнишь переполнение буфера из главы 2? Если бы каждая программа видела всю память, один сбойный (или зловредный) процесс читал бы пароли других программ и затирал чужой код. Поэтому ОС выдаёт каждому процессу изолированное адресное пространство: программа «видит» свою память, начиная с адреса 0, а процессор по таблицам ОС переводит эти «виртуальные» адреса в настоящие. Чужая память для процесса просто не существует — попытка туда залезть завершается ошибкой («программа выполнила недопустимую операцию»).
• Многозадачность. ОС распределяет время процессора между процессами, память между программами, очереди к диску и сети. Прямой доступ к железу запрещён: иначе две программы одновременно писали бы в видеопамять и на диск, превратив всё в кашу.

Как же программе что-то сделать? Она просит ОС — вызывает её функции: «открой файл», «прочитай 1024 байта», «нарисуй окно», «пошли данные по сети». Такие вызовы называются системными, а весь набор правил — API операционной системы (про API подробнее — в главе 7). Программа живёт «в песочнице» ОС: ей разрешено играть со своей памятью сколько угодно, но всё, что касается железа и других программ, — только через посредника.

Почему программа с Windows не запускается на macOS? Теперь ответ полный:

Машинные инструкции у процессоров могут быть даже одинаковыми, но программа постоянно зовёт ОС — а «язык», на котором она зовёт, у систем разный. Отсюда отдельные сборки под каждую ОС или эмуляторы-«переводчики» вроде Wine.

Все файлы делятся на два лагеря:

• Текстовые — байты внутри кодируют обычные символы: буквы, цифры, знаки. Открой такой файл в любом текстовом редакторе — увидишь читаемый текст. Примеры: .txt, .html, .md, исходный код .py, .csv.
• Бинарные — байты кодируют что угодно другое: пиксели, звук, инструкции процессора. Открой их «Блокнотом» — увидишь «кашу». Примеры: .jpg, .png, .mp3, .exe, .zip.

Граница не в расширении, а в договорённости о том, как читать байты. Эта договорённость называется форматом файла.

Как текст превращается в байты: кодировки

Символы кодируются числами по стандартной таблице. Первый массовый стандарт — ASCII (1963 год): 128 символов, ровно половина байта. Вот его самая «ходовая» часть:

Закономерности видны невооружённым глазом: цифры идут подряд с 48, заглавные буквы — с 65, строчные — с 97. Поэтому «сделать букву заглавной» — это вычесть 32 из кода, а проверка «это цифра?» — это «код между 48 и 57». Программисты до сих пор пользуются этими трюками.

В ASCII не поместились русские буквы. Каждая страна додумывала вторую половину байта (коды 128–255) по-своему: у греков — своя таблица, у турок — своя, у нас — несколько сразу (КОИ-8, CP866, Windows-1251). Победила Windows-1251 — она до сих пор встречается в старых файлах:

Проблема однобайтовых таблиц — кракозябры. Если файл сохранён в Windows-1251, а программа читает его по другой таблице, каждый байт превращается в чужой символ: слово «Привет» (байты 207 240 232 226 229 242) отображается как «Ïðèâåò». Байты те же — таблица расшифровки другая!

Полная таблица Windows-1251

Найди букву «Я»: строка «208–223», столбец «+F» → код 223. А теперь найди код 175 (строка «160–175», столбец «+F»): там символ «ї» — тот самый байт, который в UTF-8 участвует в записи буквы «Я». Совпадений мало — поэтому и кракозябры.

Выход придумали в Юникоде: единый реестр всех письменностей мира, где у каждого символа — номер (у «Я» — 1071, у 🚀 — 128640). А записывают эти номера байтами чаще всего в кодировке UTF-8. Её гениальность — в трёх свойствах:

Сколько бит на символ: от 7 до переменной длины

Сколько бит исторически отводили на один символ?

• ASCII — 7 бит. 2⁷ = 128 комбинаций, восьмой бит байта не использовался.
• Расширенные таблицы (Windows-1251 и ей подобные) — ровно 8 бит, один байт на символ. Просто и компактно, но всего 256 символов на все языки сразу не хватает — отсюда зоопарк несовместимых таблиц.
• UTF-8 — минимальная единица тоже 8 бит (отсюда «8» в названии), но символ занимает от 1 до 4 байт. Это уже не «один байт — один символ», а переменная длина.

Побочный эффект перехода на UTF-8 — файл с тем же текстом вырос. Русская буква в Windows-1251 стоила 1 байт, а в UTF-8 стоит 2: слово «Привет» — это 6 байт в 1251 и 12 байт в UTF-8; кириллический текст «подорожал» ровно вдвое. Зато латиница не изменилась (по 1 байту), а взамен мир получил одну таблицу для всех языков и эмодзи. Плата за универсальность оказалась приемлемой: память и каналы стали дешёвыми.

48 65 6C 6C 6F 21   ← так байты видит "hex-просмотрщик"
 H  e  l  l  o  !    ← так те же байты читает текстовый редактор (ASCII/UTF-8)

Текста мало: зачем понадобилась разметка

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

<!-- метки-«теги» описывают роль каждого куска текста -->
<h1>Мой реферат</h1>
<p>Это <b>очень важный</b> абзац.</p>

Зачем это нужно — разберём подробно в главе 7, а пока запомним: разметка остаётся обычным текстом, её можно писать хоть в «Блокноте», а смысл меток понимает программа-отображатель (браузер, редактор, просмотрщик).

Хитрые гибриды: что внутри .docx

Файл .docx из Word — это на самом деле ZIP-архив (помнишь магические байты PK?). Внутри лежат: document.xml — текст с XML-разметкой («этот абзац — заголовок первого уровня»), папка media — картинки как отдельные бинарные файлы, и служебные файлы настроек. Переименуй копию документа в .zip — и увидишь всё это сам. Таблицы .xlsx и презентации .pptx устроены так же.

Как ужимаются картинки

Картинка в «сыром» виде — это пиксели с числами RGB (глава 3): фото 12 Мп × 3 байта ≈ 36 МБ. Но файл .jpg этой же фотографии занимает 3 МБ. Куда делись 33 МБ? Их «выжало» сжатие — и оно бывает двух принципиально разных видов:

Пример сжатия без потерь: строка из 500 одинаковых белых пикселей фона записывается как «белый × 500» вместо 1500 байт. Пример сжатия с потерями: JPEG замечает, что в кусочке неба голубой почти одинаковый, и хранит «примерно такой градиент» — глаз разницы не видит, а байт уходит в десять раз меньше. Замечал «мыльные» квадратики на пережатых картинках? Это и есть цена lossy при слишком сильном сжатии.

Есть и третий путь — векторные картинки (.svg): это вообще текстовый файл с разметкой (родственник HTML!): «круг с центром тут, радиусом таким». Он не хранит пиксели вовсе и масштабируется без потери качества — идеален для логотипов и иконок, но бесполезен для фотографий.

Зачем вообще нужна разметка

В главе 6 метки появились как способ сказать «это заголовок». Но зачем описывать структуру текста, если можно просто сделать заголовок большими буквами в редакторе? Ответ стоит понять хорошо — это одна из главных идей всей информатики: содержимое и оформление — разные вещи, и их выгодно хранить раздельно. Плоский текст «БОЛЬШИЕ БУКВЫ» сообщает, как фраза выглядит, но не сообщает, чем она является. Метка «заголовок» наоборот: говорит о роли, а уж как её показать — решит программа-отображатель. Из этого простого разделения вытекают четыре серьёзных преимущества:

1. Один текст — много обликов. Раз содержимое и оформление разделены, один и тот же размеченный текст можно показать веб-страницей, распечатать как книгу с другими шрифтами и полями, озвучить скринридером для незрячего человека («заголовок первого уровня!») или превратить в PDF. Меняется только «слоёвка оформления» — стиль. Это как ноты: одна партитура, а сыграть её можно на пианино, оркестром или синтезатором.
2. Текст понимают машины. Поисковик видит, что фраза внутри <h1> — главный заголовок страницы, и придаёт ей больше веса. Программа может автоматически собрать оглавление, найти все таблицы, проверить все ссылки, извлечь данные. «Плоский» текст для машины — каша символов: где там заголовок, угадывай сам. Разметка превращает текст в данные.
3. Его пишут и сравнивают где угодно. Разметка — обычный текст: пиши в любом редакторе, шли в мессенджере, клади в систему контроля версий и сравнивай версии построчно («что изменил коллега вчера?»). С бинарным форматом такое сравнение невозможно.
4. Он не «протухает». Текстовый файл с разметкой откроется и через пятьдесят лет любым будущим редактором. А закрытый бинарный формат может остаться сиротой: программа, которая его читала, исчезла — и байты превратились в нерасшифрованный архив. Библиотеки и архивы поэтому любят открытые текстовые форматы.

Немного истории

• 1960-е. В издательствах редакторы помечают рукописи для наборщиков: «это заголовок», «это цитата» — первые метки ещё на бумаге. А в 1964 году появляется RUNOFF — одна из первых программ форматирования: текст набирали с командами вроде «центрировать», «абзац», а машина печатала красиво. Идея «текст + команды оформления» оказалась вечной.
• 1969 — GML. Чарльз Голдфарб с коллегами в IBM создаёт Generalized Markup Language: метки описывают не «как печатать», а что есть что («это заголовок», «это список литературы») — содержание отделено от оформления. Из трёх фамилий авторов (Goldfarb, Mosher, Lorie) и составлено название.
• 1986 — SGML. GML превращается в международный стандарт: теги в угловых скобках, документ как дерево вложенных элементов, строгие правила вложенности. SGML — дедушка всех языков разметки, но сложный: полный стандарт — сотни страниц.
• 1991 — HTML. Тим Бернерс-Ли берёт идеи SGML, радикально упрощает, добавляет главное — гиперссылку — и рождается Всемирная паутина (World Wide Web). Первые версии умели лишь заголовки, абзацы, списки и ссылки; картинки появились чуть позже.
• 1998 — XML. Строгий «порядочный родственник» для машинных данных: каждый тег обязан закрыться, регистр важен, правила жёсткие. На XML построены форматы .docx, .xlsx, RSS-ленты и тысячи служебных форматов.
• 2004 — Markdown. Джон Грубер и Аарон Шварц идут от противного: разметка должна читаться как обычный текст ещё до превращения в страницу.

HTML — язык веб-страниц

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

<h1>Космос</h1>
<p>Космос <i>очень</i> большой.
Вот почему он <b>интересен</b>:</p>
<ul>
  <li>звёзд миллиарды</li>
  <li>свет летит 8 минут
      от Солнца</li>
</ul>
<a href="https://example.com">Читать</a>

Теги — это «роли»: <h1> — заголовок, <p> — абзац, <i> — курсив, <b> — жирный, <ul> и <li> — список и его пункт, <a> — ссылка. Большинство тегов парные: открывающий <p> и закрывающий </p> обнимают содержимое. Хочешь увидеть исходник любой страницы — нажми в браузере Ctrl+U.

Как браузер показывает страницу

Что происходит, когда ты вводишь адрес и жмёшь Enter? Разберём по шагам — тут пригодится всё из предыдущих глав:

1. Запрос. Браузер обращается по сети к серверу: «пришли файл страница.html» (протокол HTTP — «протокол передачи гипертекста»).
2. Загрузка. Сервер присылает HTML-файл — обычный текстовый файл с разметкой. Байты едут по сети в память, как любые данные из глав 1–3.
3. Разбор. Браузер читает разметку и строит в памяти дерево элементов: «внутри body — заголовок h1, абзац, список из двух пунктов…». Это дерево называется DOM (объектная модель документа).
4. Догрузка. Встретив <img> или ссылку на стили (.css — правила оформления), браузер запрашивает эти файлы отдельно.
5. Отображение. Браузер вычисляет размеры и цвета каждого элемента и пишет пиксели в видеопамять (привет, глава 3!). Страница показана.

Что происходит дальше. Загруженная страница не улетает в никуда — она живёт в оперативной памяти твоего компьютера: дерево элементов, картинки, стили и работающие скрипты занимают ОЗУ, пока открыта вкладка (вкладки «тяжелеют» именно поэтому). Скрипты могут время от времени сами догружать свежие данные с сервера — так обновляется лента соцсети без перезагрузки. Но помни: ты смотришь на копию страницы, скачанную в момент загрузки. Если на сервере информация изменилась, твоя копия устарела — ты этого не увидишь, пока не попросишь свежую версию. Отсюда самая популярная «ремонтная» операция пользователя: обновить страницу — клавиша F5 (или круглая стрелка). Это буквально «сходи на сервер и загрузи всё заново»: новый запрос → новый HTML → новое дерево → новое отображение. Помогает при «зависших» скриптах, устаревших данных и странных глюках отрисовки.

Дальше начинается необязательная, но интересная часть: в HTML могут быть встроены скрипты на языке JavaScript (<script>). Это программы (помнишь главу 5: интерпретируемый язык!), которые браузер выполняет у тебя на компьютере после загрузки страницы. Скрипты — «дополнительные действия»: они могут менять дерево элементов на лету (подгружать ленту новостей, считать и показывать время, реагировать на клики), не перезагружая страницу. Статическая страница — как печатная страница: загрузил и смотришь. Страница со скриптами — как программа внутри браузера. Кстати, поэтому «отключить JavaScript» иногда чинит медленные сайты: остаётся чистый HTML.

HTTPS и сертификаты: как браузер понимает, кому доверять

Буква S в HTTPS — «secure», защищённый. Обычный HTTP передаёт данные открытым текстом: любой узел на пути (провайдер, зловредная точка Wi-Fi в кафе) может читать и подменять страницы. HTTPS шифрует канал между твоим браузером и сервером (технология TLS): подсмотреть содержимое нельзя, подменить — тоже.

Но как проверить, что сайт bank.example — действительно твой банк, а не подделка? За это отвечают сертификаты — и целая система, которая называется цепочкой доверия:

• Владелец сайта получает у центра сертификации (CA — доверенной организации) сертификат: электронный «паспорт», в котором написано «эта публичная часть ключа принадлежит bank.example» и стоит цифровая подпись центра.
• Обычно подписывает не главный центр напрямую, а цепочка: у сайта — сертификат сайта, его подписал промежуточный центр, а промежуточного подписал корневой (root) центр сертификации. Получается цепочка: «сайт ← промежуточный ← корневой».
• Корневые сертификаты — точки опоры всей системы. Их немного, и они заранее встроены в твой браузер и операционную систему (их список виден в настройках: «управление сертификатами»). Браузер при соединении проверяет всю цепочку вверх: сходится ли она с одним из встроенных корней? Сошлась — замочек в адресной строке. Не сошлась — грозное предупреждение «подключение не защищено».
• Если сертификат украли или выдали по ошибке, его отзывают: центр публикует его в списке отозванных, и браузеры перестают ему доверять, даже если срок ещё не вышел.
• В России с 2022 года действует национальный удостоверяющий центр Минцифры: он выдаёт российским сайтам сертификаты, подписанные российским корневым сертификатом. Этот корень встроен в отечественные браузеры (Яндекс Браузер, «Атом») — поэтому в них сайты с такими сертификатами открываются с замочком, даже если зарубежные центры отказались обслуживать российские организации. В браузере без этого корня тот же сайт покажет предупреждение: цепочка не сходится ни с одним известным корнем.

Суть идеи в одном предложении: доверять незнакомому сайту нельзя, но можно проверить цепочку подписей до корня, которому ты уже доверяешь. Похоже на рекомендации: «я не знаю этого человека, но его поручился мой старый знакомый, которому я верю».

Маленький абзац про API

API (application programming interface — «интерфейс прикладного программирования») — это договор о том, как программе разговаривать с другой программой. Ты уже встречал API операционной системы в главе 5 («открой файл», «покажи окно»). Тот же принцип в интернете: у погодного сервиса есть API «пришли мне город — верну температуру»; программа (или скрипт на странице) шлёт запрос GET /weather?city=Moscow и получает ответ в машинном формате (обычно JSON — текст со скобками и парами «ключ: значение»). Карты в приложении такси, оплата в интернет-магазине, ответы чат-бота в мессенджере — всё это API. Заметь красивую симметрию: человеку удобна разметка и окна, программе — API; а под капотом и там и там — байты и запросы.

JSON: универсальный язык данных

Что за «машинный формат» в ответах API? Почти всегда это JSON (JavaScript Object Notation — «запись объектов JavaScript»). Он родился как кусочек синтаксиса языка JavaScript, но оказался таким простым и удачным, что стал общим стандартом обмена данными между любыми программами — независимо от языка, на котором они написаны. Пример ответа погодного API:

{
  "город": "Москва",
  "температура": 21.5,
  "облачно": false,
  "прогноз": [
    {"день": "завтра", "температура": 19},
    {"день": "послезавтра", "температура": 23}
  ]
}

Весь синтаксис — шесть типов значений и два вида скобок:

Из этих кубиков собирается что угодно: профиль пользователя, список товаров, конфигурация программы, вызов инструмента AI-агента (глава 13!). Почему JSON победил: это обычный текст (читает человек), у него простые правила (разбирает любая программа), и он ничего не знает про конкретный язык программирования — подходит всем. Заметь симметрию: Markdown — текст для человека, понятный и машине; JSON — текст для машин, понятный и человеку. Оба живут в файлах, ездят по сети и кладутся в git — обычные байты из главы 1.

Markdown — разметка для людей

HTML многословен: даже жирный текст требует <b>...</b>. Markdown решает ту же задачу почти без «шума» — метки выглядят как естественные текстовые условности:

# Заметки о космосе

Космос **очень** большой, а
Markdown — *очень* простой.

- звёзд миллиарды
- свет летит 8 минут

1. сначала заголовок
2. потом список

> Разметка — это роли,
> а не оформление.

Вот [ссылка](https://example.com)
и `кусочек кода`.

Где ты встретишь Markdown: документация и README на GitHub, заметки в Obsidian и Notion, посты в Telegram, вопросы на Stack Overflow — и ответы чат-ботов. Это самый «ходовой» язык разметки нашего времени.

Почему Markdown так популярен

• Его одинаково удобно читать и человеку, и машине. Это редкое сочетание. HTML машина разберёт легко, а человек — с трудом среди скобок; «плоский» текст человеку понятен, а машине — нет. Markdown посередине: исходник читается как обычный аккуратный текст (звёздочки и решётки выглядят естественными «письменными» условностями), а программа превращает его в красивую страницу безошибочно. Не зря принцип авторов звучал так: «документ на Markdown должен быть пригоден для публикации как есть, простым текстом».
• Минимум церемоний. Заголовок — одна решётка, список — дефис. Руки не уходят с клавиатуры, мысль не прерывается на кнопки.
• Дружит с контролем версий. Это обычный текст: системы вроде Git показывают изменения построчно, а весь GitHub умеет отображать .md-файлы как готовые страницы.
• Конвертируется во всё. Из одного .md программы (например, pandoc) делают HTML-страницу, PDF, документ Word и презентацию — вспомни первое преимущество разметки из начала главы.
• Не привязан к программе. Заметки в Markdown переживут любой редактор: открыть их сможет даже «Блокнот» через тридцать лет.

Экранирование: как показать символ, который «занят»

Звёздочка в Markdown делает курсив. А если нужна сама звёздочка? Любой язык разметки решает это экранированием — особым способом сказать «следующий символ — просто символ, а не команда». В Markdown таким «отменяющим» символом служит обратная косая черта \:

\*не курсив\*   →  *не курсив*    (звёздочки показаны буквально)
2 \* 3 = 6      →  2 * 3 = 6
\\              →  \             (чтобы показать саму черту — удвой её)

Тот же приём — везде, только «отменяющие» конструкции разные:

• в HTML угловые скобки пишут сущностями: < вместо <, & вместо &;
• в языках программирования кавычка внутри строки — \", а перенос строки — \n;
• в адресах URL пробел и спецсимволы кодируются процентами: пробел — %20, поэтому ссылки иногда выглядят так странно.

Запомни саму идею — она универсальна: у каждого «специального» символа есть способ сказать «я не команда, я просто символ».

Исторический формат

До окон, иконок и мыши с компьютером общались только текстом. В 1970-х оператор сидел за телетайпом — устройством вроде печатной машинки, соединённой с большой ЭВМ — и вводил команды; компьютер печатал ответ на том же рулоне бумаги. Позже телетайп заменил экран с клавиатурой (терминал), а ещё позже терминал стал просто окном-программой (эмулятором терминала). Но принцип не изменился полвека: ты пишешь команду — компьютер выполняет и отвечает текстом. Это и есть консоль, командная строка, shell.

Графический интерфейс появился лишь в 1980-х как «обёртка» над теми же действиями. А консоль никуда не делась — ей до сих пор пользуются все программисты и системные администраторы. Почему?

• Скорость и точность. «Переименуй 300 файлов по шаблону» — одна строка против получаса кликов.
• Автоматизация. Команды записывают в файл — получается скрипт, то есть программа. Консоль — самый короткий путь от «действия» к «программе».
• Удалённые машины. Серверы в дата-центрах не имеют мониторов: с ними работают по сети текстом (протокол SSH).
• Воспроизводимость. Команду можно скопировать, сохранить в инструкции, проверить — в отличие от «нажми третью кнопку слева».

Основные команды Unix-подобных систем

Linux и macOS имеют общее наследие Unix; в Windows те же команды доступны через подсистему WSL, а в PowerShell есть похожие. Вот базовый набор, с которого начинают все:

Как выглядит диалог

anya@laptop:~$ pwd
/home/anya
anya@laptop:~$ mkdir реферат
anya@laptop:~$ cd реферат
anya@laptop:~/реферат$ echo "# План" > план.md
anya@laptop:~/реферат$ ls
план.md
anya@laptop:~/реферат$ cat план.md
# План

Доллар в начале строки — приглашение терминала: «готов, пиши команду». До него — подсказка, кто ты и где: пользователь anya, компьютер laptop, текущая папка ~ (домашняя) или ~/реферат.

Три приёма, которые делают консоль волшебной

• Относительные и абсолютные пути. /home/anya/фото — абсолютный путь от корня; фото или ../музыка — относительный, от текущей папки. Точка . — «здесь», две точки .. — «уровнем выше».
• Перенаправление. команда > файл отправляет вывод в файл (перезаписывая), >> — дописывает в конец. Так создают файлы из вывода программ.
• Конвейер |. Вывод одной команды подаётся на вход другой: cat заметки.md | grep кот — показать только строки про кота. Из простых команд, как из кубиков, собирают сложные действия.

И два бытовых секрета: клавиша Tab дописывает имена файлов и команд, а стрелка вверх ↑ возвращает прошлые команды. Профи почти не печатают пути руками.

Мы прошли весь путь: биты → память → процессор → файлы → форматы → разметка → консоль. Осталось соединить это с программами, которыми ты пользуешься каждый день. Текстовые редакторы (Word, Google Документы) и электронные таблицы (Excel, Google Таблицы) — это дружелюбные «лица» поверх всего, что мы изучили.

Редактор — конвертер твоих кликов в разметку

Когда ты жмёшь кнопку «Ж» в Word, программа делает то, что в главе 7 ты делал руками, — вставляет в документ метку «этот текст жирный». При сохранении редактор упаковывает текст, разметку и картинки в файл (вспомни: .docx — ZIP с XML внутри). Ты видишь красивую страницу — программа работает с байтами и разметкой.

Такой подход называется WYSIWYG — «what you see is what you get», «что видишь, то и получишь»: оформление делается мышкой и сразу видно. Противоположный подход — писать разметку руками (HTML, Markdown, LaTeX): дольше освоить, зато точнее, прозрачнее и удобнее для автоматизации. Хороший специалист владеет обоими и выбирает под задачу.

Электронная таблица — программируемый калькулятор

Электронные таблицы появились в 1979 году (VisiCalc для Apple II) и произвели революцию: впервые человек запрограммировал вычисления, не будучи программистом. Говорят, именно ради VisiCalc покупали целые компьютеры.

Таблица — сетка ячеек с адресами (привет, главы 1–3!): буква — столбец, число — строка. B2 — буквально «адрес ячейки», только не в памяти, а на листе. В ячейку можно положить число, текст — или формулу:

// A1 = 120, A2 = 80. В ячейке A3:
=A1+A2                        // 200; пересчитается сама при изменении A1 или A2
=СРЗНАЧ(A1:A10)               // среднее диапазона (в англ. версии: AVERAGE)
=ЕСЛИ(B2>=50; "Зачёт"; "Доработать")  // условие — то самое ветвление из главы 2!

Заметил? =ЕСЛИ(...) — это «сравнить и перейти» процессора в человеческом виде. Таблицы — тихая школа программирования: переменные (адреса ячеек), функции, условия, диапазоны. Два тонких момента, которые отличают уверенного пользователя:

• Относительные и абсолютные ссылки. Копируя формулу =A1*2 вниз, ты получишь =A2*2, =A3*2… — адрес «подстраивается». Доллар фиксирует адрес: =$A$1*2 при копировании не изменится. Так считают «цена × курс», где курс лежит в одной ячейке.
• Ошибки — это нормально и читаемо. #ДЕЛ/0! — деление на ноль; #ССЫЛКА! — формула указывает на удалённую ячейку; #ЗНАЧ! — в формуле несовместимые типы. Таблица «кричит», где проблема, — как интерпретатор с ошибками в коде.

Зачем знать «внутренности», если есть удобные программы

• Перестаёшь бояться. «Всё пропало», странная ошибка, файл не открывается — ты понимаешь, что внутри байты и форматы, и ищешь причину вместо паники.
• Видишь подводные камни. Расширение — не гарантия содержимого; удалённый файл часто восстановим; «прикреплённый документ» может быть программой.
• Выходишь за пределы кнопок. Консоль, Markdown и формулы автоматизируют скучное — первый шаг к настоящему программированию.
• Понимаешь AI. Нейросети — файлы с числами плюс программы, которые с этими числами работают. Теперь ты знаешь каждое слово в этом предложении — и готов к главам 11–13.

До сих пор наш компьютер был одиночкой. А теперь соединим его с миллиардами других. Хорошая новость: ничего принципиально нового не понадобится. Сеть — это те же байты, что едут из памяти одного компьютера в память другого через «особые ячейки» сетевой карты (глава 3). Всё остальное — договорённости о том, как эти байты адресовать и понимать.

Немного истории: от четырёх машин к сети сетей

• 1969 — ARPANET. Четыре университетских компьютера в США соединили в сеть. Ключевая идея: не тянуть выделенный провод между каждой парой машин (это невозможно для миллионов), а передавать данные пакетами через общую сеть, как письма через почту.
• 1983 — TCP/IP. Сети научились соединяться друг с другом по единым правилам — так родился интернет: буквально «сеть сетей».
• 1989–1991 — WWW. Тим Бернерс-Ли поверх интернета придумывает Всемирную паутину: гиперссылки, HTML (глава 7), адреса URL. Запомни разницу: интернет — это дороги и почта, веб — лишь один из видов почты (страницы), рядом едут письма, видеозвонки, игры.

IP-адрес: номер компьютера в сети

Чтобы байты знали, куда ехать, каждый участник сети получает IP-адрес — как телефонный номер. В классической версии IPv4 это четыре числа от 0 до 255 через точку: 203.0.113.7. Узнаёшь главу 1? Четыре числа до 255 — это 4 байта, 32 бита. А дальше та же беда, что и с адресным пространством: 2³² ≈ 4,3 миллиарда адресов на планету с десятками миллиардов устройств не хватило. Поэтому мир переходит на IPv6 — адреса из 128 бит (записываются длинными шестнадцатеричными группами, например 2001:db8::1): 2¹²⁸ номеров — хватит на каждый атом планеты с запасом.

Данные едут пакетами: большой файл режется на кусочки, каждый кладётся в «конверт» с IP-адресом получателя и отправителя. Специальные устройства — маршрутизаторы — работают как почтовые сортировщики: смотрят адрес на конверте и отправляют пакет в нужную сторону, от сети к сети, пока тот не доедет. Пакеты одного файла могут ехать разными дорогами!

TCP и UDP: правила доставки

Протокол — это договорённость о правилах обмена: как «формат файла», только для разговора двух программ. Пара протоколов TCP/IP решает две задачи:

• IP доставляет пакеты по адресам (но не обещает, что все доедут);
• TCP наводит порядок: нумерует пакеты, переспрашивает потерянные и собирает из них исходный поток байтов. Как отправка книги по страницам: получатель складывает страницы по номерам и просит выслать недостающие.

Есть и «лёгкий» вариант — UDP: шлём пакеты без гарантий и переспросов. Зачем? Там, где важна скорость, а не идеальность: в видеозвонке и онлайн-игре лучше потерять один кадр, чем ждать его повторной доставки.

Порты: у одного адреса много дверей

На одном сервере работает много программ: сайт, почта, база данных. Как понять, кому пакет? Для этого есть порт — номер «двери» от 0 до 65535. Соединение записывается парой: 203.0.113.7:443 — «адрес такой-то, дверь 443». За стандартными дверями живут стандартные сервисы:

DNS: телефонная книга интернета

Людям числа неудобны — им подавай example.com. Машинам наоборот — нужны IP-адреса. Переводит имена в адреса DNS (Domain Name System — «система доменных имён») — распределённая телефонная книга планеты. Когда ты вводишь адрес сайта:

1. Компьютер спрашивает ближайший DNS-сервер (обычно у провайдера): «какой IP у example.com?»
2. Тот либо знает из кэша, либо спрашивает по иерархии: корневые серверы («кто отвечает за .com?») → серверы зоны .com («кто отвечает за example.com?») → сервер владельца домена («какой IP у example.com?»).
3. Ответ возвращается и запоминается (кэшируется) на время — поэтому повторные визиты мгновенные, а смена IP у сайта «расползается» по миру часами.

Что значит «купить домен»? Домен нельзя купить навсегда — его арендуют. Ты обращаешься к регистратору — компании, аккредитованной владельцем зоны (например, зоны .ru или .com), — и за ежегодную плату (обычно несколько сотен рублей) в реестр зоны вносится запись: «домен такой-то обслуживают такие-то DNS-серверы такого-то клиента». Владение доменом = право продлевать эту запись. Дальше в панели регистратора ты заводишь A-запись: «имя example.com → IP моего сервера» — и с этого момента телефонная книга планеты знает дорогу к тебе.

Сервер: кто отвечает на запросы

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

Дата-центр, где стоят такие машины, — это здание с тысячами серверов, резервным питанием, кондиционерами и толстыми каналами связи. «Облако» живёт именно там — никакого тумана.

По проводам ездят просто байты: подглядываем за обменом

Самое приятное во всём этом: поверх TCP большинство сервисов разговаривают обычным текстом. Никакой магии — буквы и цифры, которые можно прочитать глазами (а бинарные файлы кодируют текстом — вспомни главу 6). Вот три настоящих примера.

Загрузка страницы (HTTP)

Браузер шлёт серверу текстовый запрос, сервер отвечает текстовым ответом с HTML внутри:

GET /index.html HTTP/1.1        ← браузер: "дай страницу"
Host: example.com
User-Agent: Mozilla/5.0

HTTP/1.1 200 OK                  ← сервер: "держи, всё хорошо"
Content-Type: text/html; charset=utf-8
Content-Length: 512

<html><head>...                  ← и дальше сам HTML из главы 7

Поисковый запрос

Когда ты ищешь «котики», браузер отправляет запрос, где запрос — прямо в адресе (пробелы и кириллица экранируются процентами, помнишь главу 7?):

GET /search?q=%D0%BA%D0%BE%D1%82%D0%B8%D0%BA%D0%B8 HTTP/1.1
Host: poisk.example

Отправка письма (SMTP)

Почтовая программа буквально ведёт текстовый диалог с почтовым сервером — команда, ответ:

HELO mylaptop                    ← клиент здоровается
250 Hello
MAIL FROM: <anya@example.com>    ← от кого
250 OK
RCPT TO: <boris@example.net>     ← кому
250 OK
DATA                             ← "сейчас будет текст письма"
Subject: Привет! ...
250 Message accepted

Вложение-файл в письме кодируется в текст по схеме base64: каждые 3 байта превращаются в 4 латинских символа — бинарная картинка едет внутри текстового письма. Подглядеть за обменом можно самостоятельно: в браузере нажми F12 → вкладка «Сеть» (Network) → обнови страницу — увидишь каждый запрос и ответ. А в консоли команда curl -v https://example.com покажет весь текстовый диалог с сервером.

Десять глав мы собирали пазл. Теперь посмотрим, что из него складывается, — большая языковая модель (LLM, Large Language Model): технология внутри чат-ботов вроде Kimi, ChatGPT и других. Спойлер: никакой магии. Только байты, числа и арифметика — очень много арифметики.

Что такое LLM одним предложением

Языковая модель — это программа, которая получает текст и вычисляет: какой кусочек текста логичнее всего продолжит эту последовательность. Всё. Написание сочинения, ответ на вопрос, перевод, код — всё это «угадывание продолжения», повторённое сотни раз: угадала слово — приписала его к тексту — угадала следующее. Как автоподсказка в телефоне, только невероятно умная.

Шаг 1. Токены: текст нарезают на кусочки

Компьютер работает с числами (глава 1), поэтому текст сначала превращают в числа. Но не по буквам и не по словам, а по токенам — частым кусочкам текста: целое короткое слово, часть длинного слова, знак препинания, пробел с началом слова. Специальная программа-«токенизатор» режет текст по своему словарю:

"Космонавт летит к звёздам"  →  [Космо] [навт] [ летит] [ к] [ зв] [ёздам]
"Hello, world!"              →  [Hello] [,] [ world] [!]

Каждый токен получает номер из словаря (скажем, у модели словарь на 100 000+ токенов) — и текст превращается в последовательность чисел: [4120, 881, 2753, 12, 9502, 33178]. В среднем 1 токен ≈ 2–3 русских символа, так что страница текста — несколько сотен токенов.

Шаг 2. Векторы: каждый токен — список чисел

Номер токена сам по себе ничего не говорит: токены «кот» и «кошка» — близкие по смыслу, а их номера могут отличаться на десятки тысяч. Поэтому каждый токен заменяют длинным списком чисел — вектором (тысячи координат). Эти координаты подобраны при обучении так, что у похожих по смыслу слов векторы оказываются близкими. Получается «карта смыслов»: на ней «кот» рядом с «кошкой» и «собакой», а вдали от «бюрократии». Такое представление называют эмбеддингом.

Шаг 3. Слои: арифметика из главы 2, повторённая миллиард раз

Дальше векторы токенов проходят через десятки слоёв нейросети. Каждый слой — это, по сути, гигантское вычисление вида «умножь входные числа на веса, сложи, примени простое правило». Те самые операции «умножь и прибавь» из главы 2, выполняемые видеокартами пачками. Ключевой механизм современных моделей называется внимание (attention): для каждого токена сеть вычисляет, на какие другие токены текста «смотреть» внимательнее. Благодаря этому модель в фразе «Вася сказал Пете, что он опоздает» решает, к кому относится «он» — сопоставляя веса связей между словами.

Шаг 4. Вероятности: ответ — не «истина», а «самое правдоподобное»

После всех слоёв модель выдаёт таблицу вероятностей для каждого токена словаря: насколько он подходит как следующий. Например, после «Кот сидел на»:

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

Контекстное окно: «оперативная память» модели

Модель не «помнит» разговор между сессиями: всё, что она знает о тебе прямо сейчас, — это текст текущего диалога, целиком поданный ей на вход. Его размер ограничен контекстным окном — максимальным числом токенов на вход (тысячи и сотни тысяч). Это буквально «ОЗУ» модели из главы 1: диалог вырос за пределы окна — начало вытеснилось, и модель его «забыла». Поэтому в долгом чате бот может «не помнить», о чём вы говорили вначале: это не каприз, а граница памяти.

Откуда берутся веса: обучение

В главе 11 все числа — координаты векторов и веса слоёв — были «подобраны при обучении». Как это происходит? Удивительно просто по идее и чудовищно сложно по масштабу.

1. Берут гору текстов. Книги, статьи, сайты, код — триллионы токенов. Это называется обучающей выборкой.
2. Играют в «угадайку». Берут кусок текста, прячут следующий токен и просят модель его предсказать. Например: «Москва — столица …» — правильный ответ « России».
3. Измеряют ошибку. Модель выдала вероятности; правильный токен получил, скажем, лишь 2 %. Ошибка велика.
4. Подкручивают веса. Специальный алгоритм (обратное распространение ошибки + градиентный спуск — по сути «пойди чуть-чуть в сторону уменьшения ошибки») изменяет миллиарды весов на крошечные величины так, чтобы в следующий раз правильный токен получил больше вероятности.
5. Повторяют триллионы раз. Постепенно модель начинает предсказывать текст всё лучше — а значит, вынуждена «выучить» грамматику, факты, логику, стили: иначе тексты не предскажешь.

Этот этап называется предобучением. Оно требует тысяч видеокарт, месяцев времени и электричества на миллионы долларов. Результат — «базовая» модель: она отлично продолжает тексты, но ещё не умеет быть помощником. Второй этап — дообучение на диалогах и оценках людей (инструктивная настройка, RLHF): модели показывают примеры хороших ответов и оценивают её варианты, чтобы она училась отвечать полезно, по делу и безопасно.

Почему модель «галлюцинирует»

Теперь главный практический вывод. Модель нигде не хранит «базу фактов» и не умеет отличать истину от вымысла: она умеет только оценивать правдоподобие продолжения. Поэтому:

• если в обучающих текстах что-то встречалось редко или искажённо — модель может уверенно повторить ошибку;
• если ответа модель «не знает», она всё равно сгенерирует правдоподобный текст — с несуществующими книгами, датами и ссылками. Это называется галлюцинация;
• модель не была «в интернете сегодня»: её знания ограничены датой обучения (если у неё нет инструмента поиска).

Вывод не «LLM бесполезны», а «LLM — не справочник». Правило профессионалов: факты проверяй, рассуждения и черновики — используй. Именно поэтому серьёзные AI-сервисы подключают модели к поиску: сначала найти свежие источники, потом отвечать по ним.

Что модель умеет хорошо — и почему именно это

Промпт — это техническое задание

Раз модель генерирует «самое правдоподобное продолжение», качество ответа сильно зависит от входа. Текст задания модели называют промптом. Хороший промпт похож на грамотное ТЗ — его можно собирать из блоков:

РОЛЬ:      Ты — учитель физики, объясняющий девятикласснику.
ЗАДАЧА:    Объясни, почему небо голубое.
КОНТЕКСТ:  Ученик знает, что свет — это волна, но не знает формул.
ФОРМАТ:    Сначала 3 предложения «на пальцах», потом таблица Markdown
           «что рассеивается сильнее», потом один вопрос для самопроверки.
ОГРАНИЧЕНИЯ: Без формул; если не уверен в факте — скажи об этом.

Три приёма, которые дают самый большой прирост качества:

• Дай материал. «Вот текст статьи — перескажи его» в разы надёжнее, чем «перескажи статью про…» по памяти: вспомни про галлюцинации из главы 12.
• Покажи пример. Один образец «вход → желаемый выход» задаёт стиль лучше абзаца описаний.
• Проси формат. «Ответ таблицей Markdown», «списком из 5 пунктов», «кодом с комментариями» — модель отлично держит форму, ведь она на ней и обучалась.

И главное: итерируй. Первый ответ — черновик. «Сократи вдвое», «сделай проще», «а теперь добавь пример» — диалог с моделью похож на работу с редактором.

AI-агенты: LLM + инструменты

Сама по себе модель умеет только писать текст. Но подключи к ней инструменты — поиск, калькулятор, файловую систему, консоль из главы 8 — и получится агент: система, которая работает циклом «подумай → выполни команду → прочитай результат → реши, что дальше». Разберём цикл подробно — он устроен почти как работа процессора из главы 2:

1. Модель получает контекст: твою задачу + описание доступных инструментов («можешь вызывать: поиск, чтение файла, выполнение команды в терминале»).
2. Модель «думает» текстом и решает: «чтобы ответить, мне нужно посмотреть файлы в папке». Вместо обычного ответа она выдаёт вызов инструмента — строго оговорённую запись вроде: ВЫЗОВ: терминал, команда "ls проект/".
3. Программа-обёртка (её называют средой агента) замечает такую запись, реально выполняет команду в консоли и забирает вывод.
4. Результат дописывается в контекст модели: «команда вернула: main.py, README.md». Это как шаг «записать в память» — теперь модель «видит» итог действия.
5. Цикл повторяется: модель решает, что дальше — прочитать файл (cat main.py), исправить код, запустить тест, — пока не решит, что задача выполнена, и не выдаст тебе финальный ответ текстом.

Пример итерации: как растёт контекст

Задача агенту: «найди в папке проект программу и скажи, что она делает». Проследим шаги и размер контекста (помнишь контекстное окно из главы 11?):

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

Заметь: «думает» всегда модель, а «делает» — обычная программа-обёртка. Модель не может «сломать компьютер мыслью» — она лишь просит выполнить команду, а выполнит её та же консоль из главы 8, со всеми её правами и последствиями. AI-программист, который пишет код и сам его запускает, — это ровно такой цикл: LLM, которой разрешили выполнять команды в терминале и читать их вывод.

Опасности — самые настоящие. Модель — нейросеть, а значит, ошибается: может «галлюцинировать» команду, перепутать папку, не понять побочный эффект. Если у такого агента есть доступ к консоли, одна неверная команда rm -rf не в той директории — и всё стёрто: консоль, помнишь, не переспрашивает. Поэтому правила безопасной работы агентов такие же, как правила выживания из главы 8, только строже:

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

MCP: розетка для инструментов

Откуда агент берёт инструменты? Раньше каждый AI-сервис прикручивал их по-своему: своя схема для поиска, своя — для базы данных. В 2024 году появился открытый стандарт — MCP (Model Context Protocol, «протокол контекста модели»), который быстро стал общепринятым. Идея простая и знакомая тебе по главе 7: договориться о едином разъёме, как USB-C для техники.

• MCP-сервер — маленькая программа-«адаптер» рядом с каким-то ресурсом: файловой системой, базой данных, почтой, поисковиком. Она объявляет стандартным языком: «у меня есть инструменты: прочитать_файл, список_папок; вот их параметры».
• MCP-клиент — часть AI-приложения (чата, редактора кода). Он подключается к серверам, получает списки инструментов и показывает их модели в контексте.
• Когда модель решает вызвать инструмент, клиент передаёт вызов нужному серверу по стандартному протоколу и возвращает результат модели — тот самый цикл из шагов выше, только стандартизированный.

Что это дало: инструмент пишут один раз — и он работает с любым AI-приложением, понимающим MCP. Появились каталоги готовых серверов (файлы, браузер, GitHub, базы данных), а пользователь собирает агента как конструктор: «эта модель + эти инструменты». И заметь важное для безопасности: права выдаются не «модели вообще», а конкретным серверам — сервер файлов можно ограничить одной папкой, и даже ошибка нейросети не выйдет за её пределы.

Как это выглядит на практике? MCP-сервер файлов объявляет свои инструменты в формате JSON (привет, главы 7 и 9!):

{
  "инструменты": [
    {"имя": "прочитать_файл",  "параметры": {"путь": "строка"}},
    {"имя": "список_папки",   "параметры": {"путь": "строка"}},
    {"имя": "записать_файл",   "параметры": {"путь": "строка", "текст": "строка"}}
  ],
  "разрешённая_папка": "/home/anya/проект"
}

AI-приложение подключает сервер строчкой в настройках (примерно так выглядит конфигурация у настольных AI-клиентов):

"mcpServers": {
  "файлы":   {"команда": "mcp-server-files", "аргументы": ["/home/anya/проект"]},
  "поиск":   {"команда": "mcp-server-web"},
  "github":  {"команда": "mcp-server-github", "токен": "…"}
}

С этого момента модель в этом приложении «видит» новые инструменты в своём контексте и вызывает их по имени: прочитать_файл({"путь": "main.py"}). А теперь собери всё: по сети ли сервер или локальный — общение идёт текстом (глава 9), формат сообщений — JSON (глава 7), вызовы попадают в растущий контекст (пример выше), а права ограничены настройками сервера. MCP — это просто аккуратная стандартизация того самого цикла агента.

Правила безопасной и честной работы с LLM

• Не доверяй факты на память. Даты, цифры, ссылки, цитаты — проверяй по источникам. Модель отвечает уверенно и тогда, когда выдумывает.
• Не делись секретами. Пароли, паспортные данные, чужие персональные данные в чат не вводят — это всё равно что отправить их постороннему сервису.
• Не выдавай текст модели за свою работу там, где это запрещено. Учителя и вузы имеют правила про AI; честнее использовать модель как репетитора: «объясни», «проверь мой ответ», «задай мне вопросы».
• Проверяй код перед запуском. Код от модели может содержать ошибки и даже опасные команды — читай его так же внимательно, как команды из интернета (глава 8).
• Помни про контекст. В долгом диалоге бот «забывает» начало; в новом чате он не помнит прошлый. Важное — повторяй или сохраняй отдельно.