Когда я впервые увидел, как работает быстрая сортировка, я был потрясен. В ней было что-то почти поэтическое. Горстка строк, в которых ощущался идеальный баланс — никакой избыточности, ничего лишнего. Каждая инструкция служила цели, каждая строка имела вес. Это был не просто алгоритм; это была композиция. И чем больше я сравнивал его с другими методами сортировки, которые были медленнее, тяжеловеснее и затратнее в плане времени или памяти, тем больше восхищался его чистотой.
Красота в простоте
Быстрая сортировка на C++:
void quicksort(vector<int>& arr, int left, int right) {
int i = left, j = right;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot) i++;
while (arr[j] > pivot) j--;
if (i <= j) swap(arr[i++], arr[j--]);
}
if (left < j) quicksort(arr, left, j);
if (i < right) quicksort(arr, i, right);
}
Она процедурна и механистична, но в том, как она перемещает данные вокруг опорного элемента, есть изящество — почти как в искусстве хореографии.
А теперь взгляните на тот же алгоритм, написанный на Haskell:
quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) = quicksort [a | a <- xs, a <= x]
++ [x] ++
quicksort [a | a <- xs, a > x]
Это минимализм в его лучшем проявлении. Рекурсивный, декларативный, не требующий усилий. Он больше похож на определение порядка, чем на процесс. Когда я впервые увидел его, я испытал то же удовлетворение, которое чувствует математик, когда уравнение внезапно обретает смысл.
Долгое время я был одним из тех, кто искал эту красоту — ту, что скрывается в балансе между логикой, синтаксисом и целью. Со временем эти поиски перетекли в том, что мы теперь называем лучшими практиками: чистый код, читаемость, эффективность и удобство сопровождения. Но в основе всей этой структуры лежало все то же стремление — создать нечто правильное.
Эпоха кода, создаваемого вручную
Было время, когда программисты писали код так, как поэты писали стихи. Они были помешаны на именовании, отступах и рекурсии. Одна изящная строка на Lisp или Python могла вызвать улыбку — подобно красивой последовательности аккордов. Чтение кода было актом обучения и восхищения. Проекты с открытым исходным кодом были не просто инструментами; они служили в качестве живых музеев стиля.
Помню, как листал «Искусство программирования» Дональда Кнута и понимал, что программирование никогда не сводилось лишь к тому, чтобы заставить машину работать. Оно заключалось в воплощении идей в логику, в умении мыслить достаточно ясно, чтобы компьютер мог понять тебя. В те времена можно было определить, кто написал тот или иной код. В коде заключался почерк человека, его голос.
А теперь откройте репозиторий на GitHub и спросите себя: сможете ли вы определить, был ли этот код написан человеком или моделью? И имеет ли это вообще значение?
Эпоха черного ящика
Не могу не задаваться вопросом: что произойдет с этим чувством прекрасного, когда генеративные инструменты возьмут верх? Если код будущего будут писать модели, которые не видят и не чувствуют, куда денется элегантность? Когда результат станет черным ящиком — корректным, но непонятным — кому будет важно, красив ли он?
Такое ощущение, что мы отбрасываем все, что ценили раньше, но не могли измерить. Если люди больше не будут читать код, останется ли важным такое свойство, как читаемость? Если производительность оптимизируется автоматически, зачем думать о распределении памяти? И если конечный результат просто работает, кому важно, как он был достигнут?
Недавно, работая над миграцией одного Python-пакета, я осознал, что большое количество нашего кода было написано так, а не иначе не потому, что это быстрее, а потому, что это красивее. Элегантнее. Потому что в какой-то момент пути программисты, включая меня, начали считать себя художниками.
Но когда я прошу Claude или другие генеративные инструменты отрефакторить этот код, они часто испытывают трудности. Они правильно понимают синтаксис, но упускают замысел. Упускают смыслы, которые живут между строк. Так в чем же настоящая проблема — в том, что люди обманывали себя, или в том, что генеративные модели все еще не могут постичь глубинные слои человеческого мышления?
Новые отношения с инструментами
Раньше программирование было связано с открытиями. Вы начинали с чистого листа и создавали что-то шаг за шагом, постигая суть через отладку. Сегодня программирование — это больше про выбор. Вы даете промпт модели, получаете десять вариантов и выбираете тот, который кажется правильным. Вместо вопроса «Как мне это создать?» мы теперь спрашиваем: «Какому из этих сгенерированных решений я могу доверять?»
Этот сдвиг изменил процесс обучения. Отладка, когда-то служившая нам лучшим учителем, постепенно исчезает. Вам больше не нужно вникать в логику — можно просто перегенерировать весь блок. Код работает, но понимание его работы уходит.
Новички, возможно, никогда не испытают радости наблюдать, как алгоритм разворачивается в их сознании, как приходит понимание того, почему что-то работает, а не просто факта, что оно работает. Процесс осмысления кода подменяется процессом его отбора.
Когда машины пишут код для машин
Я часто задумываюсь, кто победит в этой тихой войне: модели, которые в конечном итоге научатся писать так, как мы, художники кода, или программисты, которые смирятся с тем, что красота кода больше не важна, а имеет значение только его функциональность. Я пользуюсь этими инструментами каждый день. Они поразительны и ускоряют мою работу. И все же я работаю вместе с блестящими инженерами, которые их избегают.
Думаю, частично такое сопротивление вызвано нежеланием отказываться от творческой составляющей. Писать код когда-то означало оставлять после себя след — свой вкус, свою дисциплину, ход своих мыслей. Теперь это больше похоже на отбор результатов чужого интеллектуального труда.
Это не то же самое, что создаваемые ИИ картины или музыка, где машина все еще творит для людей. Здесь машины пишут для машин.
Мы, люди, просто потребляем конечный результат: работающее API, веб-приложение, дэшборд. Речь уже не идет об элегантности. Больше нет кода, который ощущается как что-то, что было создано вручную.
Исчезающее мастерство
Есть и другой аспект, показывающий, насколько система все еще хрупка. Если большая часть нового кода генерируется, то на чем мы обучаем наши модели? На существующем коде, написанном человеком, но также и на растущем океане кода, созданного ИИ, который, возможно, больше не несет в себе человеческой логики. Если это так, то красота не просто угасает — она исчезает. Ведь следующее, чему научится модель, — это паттерны из паттернов, лишенные изначального замысла, который их сформировал.
Что произойдет, когда мы столкнемся с техническим долгом? Поймут ли наши самые умные инструменты генерации кода, что делать с давно написанным фрагментом кода, глубоко кастомизированным, запутанным, но эффективным? Или нам придется нанимать одного из тех оставшихся инженеров, которые все еще используют прежние образцы мышления, подобно тому, как банкам приходилось снова брать на работу программистов на COBOL, потому что никто, кроме них, не мог прочитать код?
Что же уцелеет?
Возможно, красота не умирает. Возможно, она просто переходит в иное качество. Может статься, в будущем изящество будет жить не в строках кода, а во взаимодействии между человеком и машиной — в том, как мы формулируем промтпы, оркестрируем агентов или определяем логику на более высоких уровнях абстракции. Возможно, мы начнем восхищаться другим видом ясности — способностью точно и эмпатично переводить человеческое намерение в машинное мышление.
Это может стать новой формой искусства. Дизайн промптов как поэзия. Архитектура систем как композиция. Проектирование потоков как повествование. Это не та красота, на которой мы выросли и которую можно было прочесть строка за строкой, но та, которая все еще может быть искусством, принадлежащим тому гибридному миру, который мы строим.
Эпилог: Красота как побочный продукт
Возможно, в этом и заключается ирония. Раньше мы вкладывали красоту в код, потому что должны были его видеть. Скоро мы, возможно, будем создавать код, который не сможем увидеть вовсе.
И все же я верю, что в этом стремлении было нечто ценное — не потому, что оно делало программное обеспечение лучше, а потому, что совершенствовало нас самих. Оно учило нас заботиться о структуре, уважать логику, находить гармонию между хаосом и порядком. Оно напоминало нам, что за каждой функцией когда-то стояла человеческая рука, пытавшаяся не только заставить что-то работать, но и сделать это прекрасным. Хотя бы саму малость.
Читайте также:
- Чистота и порядок: 3 правила для идеальной базы кода
- Формирование эффективной и целостной культуры ревью кода
- Как писать понятный код
Читайте нас в Telegram, VK и Дзен
Перевод статьи Alessandro Romano: The Lost Beauty of Code
