Привет, Хабр!

Меня зовут Артем Лакомов, я филолог из МГУ. Да, вы не ослышались. И сегодня я хочу поговорить с вами о самой главной (и самой дорогой) боли в IT, но с совершенно неожиданной стороны.

Каждый из вас хоть раз в жизни видел код, от которого хотелось плакать или же тихо ненавидеть свою работу. Код с переменными вроде data, res, temp. Код, где есть один гигантский класс, который делает абсолютно всё, и коллеги с любовью (или ужасом) называют его godObject.

Все привыкли думать, что это просто «плохой стиль» или «технический долг». Но что, если я скажу вам, что это — не техническая, а языковая проблема? И что у монструозного godObject гораздо больше общего со школьным прозвищем «Толстый», чем вы думаете?

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

Давайте я покажу вам, как теория прозвищ, разработанная великим отечественным лингвистом А.В. Суперанской, вскрывает то, о чем инженеры только догадывались интуитивно, но, увы, не могли сформулировать.

1. Именование «от взора и естества» (или «Что вижу, то пою»)

Суперанская пишет, что самый базовый тип прозвищ отражает очевидные, бросающиеся в глаза свойства: Громадила, Рыжий, Очкарик. Узнаете?

Это ваш godObject. Это ваш spaghettiCode.

Это имя-диагноз, которое дается не за функцию, а за внешний вид и внутреннее устройство — его чудовищный размер или запутанную структуру. Это точная копия прозвища Громадила или Трёхтонка. Имя здесь — не просто ярлык, а оценочное суждение всего коллектива.

А еще это ваши utils, manager, handler — имена, которые ничего не говорят о функции, но многое — о том, что автор не знал, как назвать. Как прозвище «Тихоня» для того, кто просто не любит говорить.

2. Именование «от вещи» (или Великая Сила Метафоры)

Как назвать сложный процесс обработки данных? Конечно, DataPipeline (конвейер данных). А систему защиты? Firewall (огнеупорная стена). Здесь мы просто берем понятный объект из физического мира и переносим его свойства на абстрактную цифровую сущность.

Это в точности ономастическая модель «от вещи», как прозвище Колхида для водителя грузовика этой марки. И хороший инженер отличается от плохого именно умением найти точную, интуитивно понятную метафору.

3. Именование «от прецедента» (или Привет, гик-культура!)

А вот тут начинается самое интересное. Это высший пилотаж именования.

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

Yoda Conditions: Конструкция if ("constant" == variable). Названа в честь магистра Йоды за инвертированный порядок слов.

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

Зачем мы это делаем? Суперанская отвечает: такие прозвища (Аниськин, Белинский) работают как маркер принадлежности к группе. Они выполняют две важнейшие функции.

Сжимают информацию: Сказал Heisenbug — и коллега мгновенно понял всю сложность проблемы.

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

4. Именование «от притчи» (или «Шрамы, которые мы оставляем в коде»)

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

В коде это — один из самых мощных прагматических инструментов. Каждый раз, когда вы видите имена вроде:

legacyAuthFix

hotfixForTicketJIRA123

tempWorkaroundForIE6

...перед вами не просто имя, а имя-нарратив. Оно рассказывает целую историю: «Этот код — костыль, потому что старая система аутентификации отвалилась», «Это срочная заплатка для конкретной задачи в Jira, не трогай ее, пока не прочитаешь тикет», «Это временное решение для проклятого Internet Explorer 6, и мы все надеемся его когда-нибудь удалить».

Или же возьмем для примера следующие наименования: 

quickFixForDemo

dontTouchThisItWorks

// TODO: refactor this mess

Каждое такое имя — это предупреждение будущим поколениям разработчиков: «Здесь была битва. Здесь принимались сложные решения. Осторожно.»

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

Так что же делать? Три принципа, которые изменят ваш код

Хорошо, скажете вы, это все очень интересно, но что мне с этим делать завтра на код-ревью?

Все эти параллели между прозвищами и идентификаторами — не просто красивое наблюдение. Они приводят нас к трем очень практическим выводам, которые вы можете начать применять прямо сейчас.

  1. Осознайте свою роль. Вы — Ономат (name-giver). 

    Каждый раз, когда вы пишете let data = ..., вы не просто создаете переменную. Вы совершаете акт номинации. Вы даете имя новой сущности в вашем маленьком мире. Подойдите к этому не как к рутине, а как к важнейшей части вашей работы. Ваше имя — это первое, что увидит другой человек. Это ваш шанс объяснить ему суть, помочь или, наоборот, навсегда запутать. Подобно автору, выступающего в роли того, кто дает имя, вы создаете уникальных персонажей в своем собственном произведении.

  2. Думайте о «читателе», а не только о «писателе».

    Самая частая ошибка — давать имя, понятное только вам в данный момент. Теория Суперанской и практика IT доказывают: имя существует не для вас, а для коллектива. Перед тем как назвать переменную temp, спросите себя: «Поймет ли мой коллега через полгода, что здесь имелось в виду, без моих устных комментариев?». Если ответ «нет» — ищите другое имя.

  3. Исповедуйте «Принцип семантической полноты».

    В итоге, все сводится к одному. Хорошее имя — это то, которое обладает семантической полнотой и предсказуемостью. Оно должно исчерпывающе отвечать на вопрос «что это?» и позволять предсказать, «как оно себя ведет». Имя archive_inactive_users_and_notify() длинное, но оно идеально. Оно полное и предсказуемое. Имя proc_users() — короткое, но бесполезное. Оно скрывает суть, а не раскрывает ее.

Чтобы разница была еще нагляднее, давайте просто посмотрим на примеры в таблице:

Плохо (Имена-диагнозы, скрывающие суть)

Хорошо (Имена-действия, раскрывающие суть)

data, info, temp, item, list

userProfile, emailList, validUsers

utils, helper, manager, handler

EmailValidator, TaxCalculator, CurrencyFormatter

doStuff(), handleIt(), processData()

parseUserInput(), sendNotification(), updateUserProfile()

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

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

Заключение: Код — это гуманитарная дисциплина

Мы привыкли думать о программировании как о чисто технической сфере. Но чем дальше, тем очевиднее становится то, о чем писал еще Дональд Кнут: 

программы пишутся для людей.

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

И всегда помните: каждый раз, когда вы пишете let data = ... , где-то плачет филолог. Не потому что это технически неверно, а потому что вы упускаете шанс рассказать историю. А хороший код, как и хорошая литература, всегда рассказывает историю.

Спасибо за ваше время!

А теперь идите и посмотрите на свой код свежим, филологическим взглядом. Уверен, вы увидите много интересного.
(И, конечно, жду ваших любимых примеров странных, гениальных или ужасных имен в комментариях!)

Об авторе

Артем Лакомов

аспирант кафедры английского языкознания филологического факультета МГУ им. М.В. Ломоносова, преподаватель РТУ МИРЭА

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

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

Комментарии (13)


  1. apevzner
    26.08.2025 09:12

    There are only two hard things in Computer Science: cache invalidation and naming things.

    — Phil Karlton


    1. art_lak Автор
      26.08.2025 09:12

      Идеальный комментарий, спасибо! Вы привели вторую половину уравнения, которое я пытался решить в статье. Все знают, что именование — это сложно. Но ПОЧЕМУ?

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

      Моя статья — это, по сути, попытка применить филологический инструментарий к этой «второй самой сложной вещи».


      1. apevzner
        26.08.2025 09:12

        Это сложно потому, что наш "рабочих набор" слов и понятий довольно маленький (не общий словарный запас, а те слова, которые "под рукой"). Особенно на иностранном языке, всё же приличные люди используют в программах английскую лексику.

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

        В хорошо написанной программе присутствует система наименования вещей, и она консистентна. Удобно, когда однородным объектам даются однородные имена. И, скажем, если я вижу класс по имени DeviceLocator, я вправе ожидать, что описан он будет в файле по имени devicelocator.xxx, а не discoveryservice.xxx - иначе как мне искать его реализацию среди нескольких сотен файлов?

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

        Всё это не упрощает выбор имен для сущностей.

        В вашей статье есть один существенный недостаток: вы рассуждаете о наименовании понятий ("ошибка Гейзенберга"), но сказать пытаетесь о наименовании переменных и функций.

        Никто не назовёт свой класс godObject или свою функцию SpaghettiCode (хотя с радостью используют эти слова, чтобы охарактеризовать, но не назвать, какое-либо место в программе).

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


  1. ionicman
    26.08.2025 09:12

    Нет, код, увы это не гуманитарная дисциплина. Нейминг внутри кода - может быть.

    Для себя я определил очень простые пункты для понятного именования:

    1. называть так, чтобы можно было понять в текущем контексте что это

    2. текущий контекст - это модуль + класс + фя (в простом приближении)

    3. не добавлять у именам название контекста - те Array.isArray - это очень плохо

    4. имена формировать как "что" (существительное) + "делает" (глагол), например emailValidate

    5. lowerCamelCase

    Но вообще все ИМХО, главное чтобы был описанный стандарт, принятый в команде и все его придерживались.


    1. art_lak Автор
      26.08.2025 09:12

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

      И ваши правила — блестящий тому пример. Смотрите:

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

      А ваша формула «"что" + "делает"» (emailValidate) — это классический пример того, что филологи называют именем с ясной «внутренней формой».

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

      Спасибо еще раз, что поделились своей системой. Очень интересно, это результат вашей личной практики или вы пришли к нему вместе с командой?


    1. apevzner
      26.08.2025 09:12

      Но вообще все ИМХО, главное чтобы был описанный стандарт, принятый в команде и все его придерживались.

      А еще лучше - инструментарий, который мягко но настойчиво навязывает этот стандарт.


    1. faraway644
      26.08.2025 09:12

      Тут семантическая ошибка в 3 пункте. email не является субъектом валидации, он не делает ее. Это существительное в винительном падеже. Поэтому должен стоять после: validateEmail.

      Существительное, которое отвечает на вопрос - "Что делает?" - это и есть контекст - класс. например: EmailValidator. И имя метода в таком случае, чтобы не дублировать контекст, будет просто validate:
      validate(email: String)


  1. artptr86
    26.08.2025 09:12

    А что вы, собственно, сказать хотели? Что у людей существует некий ограниченный набор принципов, по которым они называют сущности? И что программисты тоже люди, которые следуют тем же принципам? В чём именно ваше «поразительное» открытие? Если в вашей статье убрать пафос и очевидные истины, то в ней почти ничего не останется.

    В целом выводы по именованию переменных, конечно, правильные, но их и до вас придумали. Только я бы заменил соответствующую картинку: никто в здравом уме не назовёт переменные godObject, spaghettiCode или messyData. Это всё антипаттерны, которые характеризуют код, а не именованные сущности этого кода.


  1. Keeper22
    26.08.2025 09:12

    Я дам тебе имя --
    Вот важнейший приём колдовства


  1. tri_tuza_v_karmane
    26.08.2025 09:12

    Я уже как-то думал на эту тему вот здесь: https://habr.com/ru/articles/743114/ и пришел к выводу что не нужно так сильно заботиться о наименованиях.

    Мы ведь пишем-таки для машин.

    Текстовый код - это промежуточная стадия в трансляции техзадания в бинарник.
    Без машины он бесполезен даже в качестве учебного пособия.
    И заботиться надо не о людях, а о том, чтоб оно корректно работало.
    Люди уйдут, придут, снова уйдут, а код останется отражать техзадание.
    Поэтому слишком загружать себя правильными наименованиями смысла нет, только впустую время тратить.

    Так что ваше исследование может и интересно с филологической точки зрения, но большинство программистов не филологи, поэтому если они побегут его применять, то сделают это максимально неправильно.


    1. randomsimplenumber
      26.08.2025 09:12

      Мы ведь пишем-таки для машин.

      Для людей.


    1. Gordon01
      26.08.2025 09:12

      Мы не пишем код для машин. Машины понимают практически любой код, даже такой https://www.ioccc.org/

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

      Удивительным образом "хороший" код, понятный людям без подсказок в подавляющее большинстве случаев - корректный.

      А отношение других людей к вашим мыслям и статьям достаточно отражено в комментариях и оценках.


  1. KEugene
    26.08.2025 09:12

    Представляете, как нейтивам тяжело учиться программированию! Вот для вас команды и ключевые слова, формирующие синтаксис, функции - все в единственном экземпляре. "Const" и в Африке "const". А у нейтивов почти для каждого слова может оказаться по несколько синонимов. Попробуй запомнить, что из них команда, а что просто часть языка общения. Я уже молчу про написание: center vs centre. Если всю жизнь пишешь centre, то тяжело помнить, что именно тут надо писать "с ошибкой".