Как я осознал, что не умею кодить

Вчера мой скрипт завис. Процессор горел на 100%. Я убил процесс.

Я Senior Developer с 10 годами опыта. Пишу на Python, знаю Java и много модных фреймворков. Но в этот момент я понял: я не умею программировать. Точнее, я умею использовать инструменты. Но я не понимаю природу вычислений.

Эта статья — о том, как одна математическая задача изменила моё понимание разработки.

И почему через пару лет, когда ИИ будет писать весь код за меня, это понимание станет единственным, что меня спасёт.

Возможно, и тебя тоже.

Иллюзия абстракции

Мы живём в эпоху максимального удобства. Нужна сортировка?.sort()Нужно распознать лицо? Подключаем API. Нужна модель? Auto ML.

Это хорошо для бизнеса. Time-to-Market сокращается. Продукты выходят быстрее. Компании зарабатывают больше. Но есть цена: мы теряем "чувство материала". Мы перестаём ощущать вес вычислений.

Джун пишет вложенный цикл по массиву из миллиона элементов. Не чувствует боли. Процессор "съедает" всё за секунду.

Потом этот код попадает в продакшн с 10 000 пользователей одновременно. Серверы падают. Бизнес теряет деньги. CTO орёт на команду. И джун не понимает, что пошло не так. Ведь у него на ноуте все работало.

Разница между джуном и инженером не в знании синтаксиса. Она в способности почувствовать катастрофу до запуска. И вот задача, которая научила меня этому чувству.

Задача, которая всё изменила

Представь треугольник из чисел:

   3
  7 4
 2 4 6
8 5 9 3

Правила простые:
- Начинаешь с вершины (число 3)
- Двигайся вниз, выбирая левого или правого соседа
- Цель: найти путь с максимальной суммой чисел

В примере выше оптимальный путь: 3 → 7 → 4 → 9 = 23.

Задача с треугольником из 15 строк решается за секунду перебором. Но что, если в треугольнике 100 строк?

Первая реакция разработчика

"Напишу рекурсию, которая проверит все пути и выберет лучший".

def find_max_path(triangle, row=0, col=0):
    if row == len(triangle) - 1:
        return triangle[row][col]

    left = find_max_path(triangle, row+1, col)
    right = find_max_path(triangle, row+1, col+1)

    return triangle[row][col] + max(left, right)

Запустил на треугольнике из 15 строк. Ответ получил за доли секунды.

Отлично! Запускаю на треугольнике из 100 строк. Подождал минуту, пять, десять. Процесс завис.

Математика катастрофы

Давайте посчитаем, что происходит. На каждом шаге путь раздваивается. У нас 100 шагов. Количество возможных маршрутов = 2⁹⁹ ≈ 6.3 × 10²⁹. Число с 30 нулями.

Если представить, что у нас есть суперкомпьютер, который проверяет 1 миллиард маршрутов в секунду, то на это уйдет 20 миллиардов лет.

В этот момент я понял: проблема не в Python. Не в памяти. Не в процессоре.

Проблема в том, как я думаю.

Мой алгоритм математически обречён, какой бы мощный сервер я ни арендовал.

Смена парадигмы

Решение требует фундаментального сдвига в ментальной модели. Вместо того чтобы стоять на вершине и гадать, какой путь выбрать (смотреть в будущее), нужно начать с конца. Пойти из будущего в настоящее.

Посмотрите на предпоследний ряд:

  2 4 6    <-- Текущий ряд
 8 5 9 3   <-- Основание

Возьмём число 2. У него два потомка: 8 и 5. Если мы когда-нибудь придём в точку 2, мы обязательно пойдём к 8, потому что это выгоднее. Значит, реальная ценность клетки "2" = 2 + 8 = 10.

Возьмём число 4 (посередине). Его потомки: 5 и 9. Лучший выбор: 9. Ценность клетки "4" = 4 + 9 = 13. И т.д.

Теперь предпоследний ряд превратился в:

10 13 15

Последний ряд больше не нужен. Он "схлопнулся" в предпоследний. Треугольник стал на одну строку меньше. Повторяем процесс 99 раз, поднимаясь к вершине.

# Идём снизу вверх
for i in range(len(triangle) - 2, -1, -1):
    for j in range(len(triangle[i])):
        # К текущему числу прибавляем лучший вариант из нижнего ряда
        triangle[i][j] += max(triangle[i+1][j], triangle[i+1][j+1])

print(triangle[0][0])

Три строки кода. Вместо 20 миллиардов лет вычислений (O(2ⁿ)), процессор решает задачу за 0.002 секунды (O(n²)). Это торжество инженерного мышления над грубой силой.

Где это работает в реальной жизни?

Эта логика управляет миром вокруг нас. Когда Photoshop сжимает фото и оставляет лицо нетронутым (Seam Carving) — это тот же треугольник, только ищется путь с минимальной энергией.

Когда трейдеры оценивают опционы (Binomial Pricing) — они сворачивают дерево вероятностей от будущего к настоящему.

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

Один принцип, тысячи применений.

Как развить это чувство?

Но как научиться видеть эти паттерны? Как развить интуицию, которая кричит "Стоп!" до того, как ты напишешь O(2ⁿ)?

Инженерное мышление — это навык. И как любой навык, его нужно тренировать.

Именно для этого существует Project Euler — платформа с более 900 задачами разной сложности. Обожаю её.

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

Взять ручку и бумагу. Найти математическую закономерность. И только потом касаться клавиатуры. После решения каждой задачи — кайф. Не от того, что ты победил систему. А от того, что ты увидел то, что было невидимо.

Ты начинаешь чувствовать вес цикла. Когда ты видишь O(2ⁿ), у тебя сжимается сердце.

Системное решение задач прокачивает программистское IQ — способность видеть неэффективность до запуска кода. И это умение станет критически важным совсем скоро.

Что останется, когда придёт ИИ?

Через пару лет ИИ будет писать весь код за меня. Что тогда останется?

• Способность понять, что задача неразрешима перебором.

• Интуиция, которая подскажет: "Иди с конца".

• Инженерное мышление, которое превращает 20 миллиардов лет в 2 миллисекунды.

Что останется навсегда

Инструменты меняются. Вчера был jQuery. Сегодня React. Завтра что-то, сгенерированное ИИ. Но сложность O(2ⁿ) навсегда останется сложностью O(2ⁿ).

Project Euler возвращает к основам. Он напоминает: за любым красивым интерфейсом всегда стоит "железо" и математика.

И понимание того, как превратить 20 миллиардов лет в 2 миллисекунды — это то, что отличает настоящего инженера от пользователя IDE.

Вчера мой скрипт завис.

Сегодня я знаю, почему.

Завтра, когда ИИ будет писать код за меня, я всё ещё смогу сказать ему: "Твой алгоритм обречён. Начни с конца".

Время чтения: 8 минут.
Время экономии вычислений: 20 миллиардов лет.

P.S. А с другой стороны, зачем мне прокачивать инженерное IQ, если ChatGPT может проверить сложность и написать оптимальное решение? Зачем решать задачи на Project Euler, если Claude сделает это за меня?