OLD SCHOOL

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

🖥️ Пролог: жёлто-зелёный рассвет

Помните это?

Жёлто-зелёный логотип Windows 98. Медленно ползущая полоска загрузки. Звук запуска, от которого по коже бежали мурашки. И вы — с сияющими глазами — сидите перед ЭЛТ-монитором весом под 20 килограмм, который греет комнату лучше батареи.

Вам казалось, что это — вершина технологий. Что круче уже ничего не придумают.

Прошло 30 лет.

Сегодня я открываю Cursor, пишу промпт на человеческом языке, и через 3 минуты у меня готов микросервис с авторизацией, тестами и документацией. А в детстве я писал на QBasic и радовался, если программа складывала два числа без ошибки.

Давайте вернёмся в те времена. Вспомним, каково это — быть разработчиком в эпоху, когда «загрузка» была ритуалом, а не прогресс-баром.

---

💾 Часть 1. Тогда: код как магия, а магия — как жизнь

Первое знакомство: QBasic и синий экран

Моим первым языком был QBasic.

Я открывал его через DOS. Синий фон. Белый курсор. И никаких тебе подсветок, автодополнений, подсказок. Только ты, клавиатура и логика — голая, как провод.

basic INPUT "Введите ваше имя: ", name$ PRINT "Привет, " + name$ + "!"

Это была магия. Я вводил текст, компьютер понимал меня и отвечал. Казалось, я управляю вселенной.

Ошибка? Получи синтаксическую. Или, что ещё хуже, — логическую. Программа просто НЕ ДЕЛАЛА то, что ты ожидал. Никаких отладчиков. Только PRINT в каждой строке, чтобы понять, где сломалось. Я ставил PRINT "ТУТ" через каждые три строки. Это был мой первый дебаггер.

А потом был Turbo Pascal с его синим экраном и менюшкой сверху. Я писал свои первые алгоритмы: сортировки, поиск, рекурсия. Это было сложно. Это было красиво. Это было непонятно, но безумно интересно.

И помню тот день, когда я впервые нарисовал круг на экране. На Pascal. Через модуль Graph. Это было невероятно — я управлял пикселями! Сейчас это делает CSS за одну строку: border-radius: 50%. А тогда это было искусство. Я писал по 50 строк, чтобы просто нарисовать окружность, и чувствовал себя Леонардо да Винчи.

Олимпиады по программированию: битва умов

Я участвовал в олимпиадах. Школьных. Городских. Областных.

Мы сидели в душных классах, за компьютерами с Windows 95/98, и решали задачи на алгоритмы. Время — 3–4 часа. Язык — Pascal или C++ (если повезло с компилятором).

Никакого интернета. Никаких подсказок. Никаких ChatGPT. Только ты, твой мозг и листок бумаги, на котором ты проектировал решение.

Задачи были зверские:

- Найти кратчайший путь в графе из 1000 вершин - Оптимизировать рюкзак с 500 предметами - Реализовать алгоритм сжатия строки - Обойти лабиринт, не зная его карты

И если у тебя программа работала дольше 2 секунд на тестовых данных — ты вылетал. Потому что олимпиадный сервер считал время. Железо. Без компромиссов.

Это было сурово. Это было честно. Это закаляло характер.

Я помню, как мы с одноклассником спорили до хрипоты, какой алгоритм сортировки быстрее на почти отсортированном массиве. Мы не гуглили — мы спорили, писали код, прогоняли вручную на бумаге, пересчитывали O-большое. Это была чистая наука. Инженерия в первозданном виде.

Ассемблер: когда ты касаешься сердца машины

Я успел попробовать Ассемблер.

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

asm mov ax, 5 mov bx, 10 add ax, bx

Три строки, чтобы сложить два числа. На C это было бы int sum = 5 + 10;. На Python — sum = 5 + 10. На QBasic — sum = 5 + 10.

Но в Ассемблере ты чувствовал, что ДЕЛАЕШЬ. Что ты не просто просишь компьютер что-то сделать — ты говоришь ему, КАК именно это сделать. На каком регистре хранить. Какой флаг выставить. Куда записать результат.

Это было искусство. Но это было чудовищно сложно.

Одна ошибка — и программа падает. Две ошибки — и висит система. Три ошибки — и ты переустанавливаешь Windows.

Я помню, как потратил три дня, чтобы написать простой загрузчик на Ассемблере. Три дня. 100 строк кода. Зато он работал. И я чувствовал себя богом.

Реальность тогдашнего разработчика

Разработчик в конце 90-х — начале 2000-х — это был одинокий волк.

У тебя нет интернета (или есть, но медленный, дорогой, и ты платишь за минуту). Нет Stack Overflow. Нет GitHub. Нет npm, pip, yarn. Нет даже нормальной документации — только книги, которые ты покупал в книжном магазине, и HELP в DOS.

Чтобы решить проблему, ты:

- Листал книгу по 20 минут, пока найдёшь нужный раздел - Писал код на бумаге, прежде чем ввести его в компьютер - Запускал — и молился - Смотрел на ошибку и думал, что она значит - Снова листал книгу, чтобы понять, что ты сделал не так

Это занимало часы. Но это учило тебя думать. Глубоко. Медленно. Основательно.

Ты не мог позволить себе быть поверхностным. Ты должен был понимать, как работает компьютер: память, процессор, прерывания, порты ввода-вывода. Ты знал, что такое сегментация памяти. Ты знал, что такое виртуальная память. Ты знал, как устроен FAT16.

Потому что без этого ты не мог написать даже простую программу.

---

⚡ Часть 2. Теперь: бездна абстракций

От Ассемблера до промпта — один прыжок

Прошло 30 лет.

Сегодня я не знаю, на какой частоте работает мой процессор. Мне это не нужно.

Я не знаю, сколько регистров у ARM-архитектуры. Мне это не нужно.

Я не знаю, как работают прерывания в Linux. Мне это не нужно.

Я открываю IDE. Пишу промпт на русском языке:

«Сделай мне CRUD для постов с комментариями. Авторизация по JWT. База — PostgreSQL. Кеш — Redis. Покрой тестами.»

И через 5 минут у меня есть работающий микросервис.

Цепочка абстракций

Посмотрите на эту цепочку:

text Ассемблер (1980-е) → C (1990-е) → C++ (2000-е) → Java/C# (2000-е) → Python/Ruby (2000-е) → JavaScript/TypeScript (2010-е) → React/Vue (2010-е) → ИИ-ассистенты (2020-е) → Промптинг (2024-2026)

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

Сегодня мы пишем не код. Мы пишем контракты для ИИ. Мы не говорим машине «сделай так», мы говорим ей «сделай, чтобы было так». А как — она решает сама.

Это невероятный прогресс. Но он имеет цену.

Цена абстракции: потерянное понимание

Я вижу это каждый день. Молодые разработчики (я их называю «вайб-кодеры») не знают:

- Как работает TCP/IP - Что такое системный вызов - Как аллоцируется память - Разницу между стеком и кучей - Что такое прерывание - Как работает планировщик процессов - Что такое кэш-промах

Им это не нужно. Они работают на уровне React-компонентов и ORM-запросов. ИИ пишет за них код. Они только проверяют.

Но они не знают, что происходит «под капотом». Они не могут объяснить, почему одно решение работает быстро, а другое — тормозит. Они не понимают, почему их база упала под нагрузкой в 1000 пользователей.

Им кажется, что они разработчики. На самом деле — они операторы ИИ.

Что мы потеряли?

Мы потеряли глубину.

Раньше ты знал свой инструмент до последнего бита. Ты понимал, как работает компилятор. Ты знал, что такое оптимизация циклов. Ты мог написать программу, которая работала в 2 раза быстрее за счёт правильной работы с памятью.

Сегодня ты не знаешь, как работает V8 или JVM. Ты не знаешь, почему одна строка кода на Python медленнее другой в 100 раз.

Мы выиграли в скорости разработки, но проиграли в глубине понимания.

---

🧠 Часть 3. Я был тем и стал этим: эволюция личности

Тогда: я — программист

Я писал на QBasic и Pascal. Участвовал в олимпиадах. Смотрел на ассемблерный код и чувствовал себя посвящённым.

Я был программистом. Я писал код. Я исправлял ошибки. Я оптимизировал алгоритмы. Я знал, как работает память, процессор, операционная система.

Я был одинок. Но я был свободен.

Теперь: я — архитектор

Сегодня я — архитектор решений.

Я не пишу код. Я описываю системы. Я проектирую контракты. Я управляю ИИ, который пишет код за меня.

Я не знаю, сколько регистров у процессора. Мне это не нужно.

Я знаю, как спроектировать систему, чтобы она выдерживала 10 000 пользователей. Я знаю, как обеспечить безопасность. Я знаю, как выбрать правильную базу данных. Я знаю, как организовать CI/CD, чтобы релиз не превращался в кошмар.

Я больше не кодер. Я — архитектор.

Что осталось неизменным?

Осталось главное: мышление.

Способность декомпозировать задачу. Способность видеть систему целиком. Способность принимать компромиссные решения. Способность учиться и переучиваться.

Раньше я писал PRINT для отладки. Теперь я пишу промпты для Cursor.

Раньше я искал ошибку в коде. Теперь я ищу ошибку в контракте.

Раньше я оптимизировал сортировку. Теперь я оптимизирую промпт.

Суть осталась той же. Изменились только инструменты.

---

💎 Часть 4. Что дальше?

Профессия не умирает — она трансформируется

Разработчики не исчезнут. Они станут другими.

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

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

Наш путь — это пример

Мы прошли путь от Ассемблера до промптинга. Это путь эволюции. И он не закончен.

Через 10 лет мы будем смотреть на сегодняшние промпты так же, как смотрим на QBasic. С улыбкой. С ностальгией. И с чувством гордости — что мы были частью этого великого пути.

Но кое-что останется неизменным.

Любовь к созданию. Любовь к решению сложных задач. Любовь к тому моменту, когда программа запускается и делает то, что ты задумал.

Это не меняется. Ни через 30 лет. Ни через 100.

---

🎯 Послесловие: обращение к вам

Если вы помните Windows 98, QBasic и Turbo Pascal — мы из одного поколения.

Если вы писали на ассемблере и участвовали в олимпиадах — мы из одной школы.

Если вы сейчас проектируете системы с помощью ИИ — вы на правильном пути.

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

И знаете что?

Я не хочу возвращаться в прошлое. Я хочу идти дальше.

Но иногда, когда я слышу звук запуска Windows 98, моё сердце замирает. Потому что это — часть меня. Часть моего пути. Часть того, кем я стал.

Спасибо, Windows 98. Спасибо, QBasic. Спасибо, Turbo Pascal. Вы научили меня думать. Вы научили меня создавать. Вы научили меня быть.

А теперь — давайте создавать будущее.