Слепая дегустация для кода

Привет, Хабр. Я Полина, продакт и главный редактор медиаплатформы «Своё Вино» от Россельхозбанка. Помните, не так давно мы говорили с вами о том, что общего у вина и ИТ? На платформе «Своё вино» мы с редакцией обычно говорим о терруарах, стилях и винтажах, но в этот раз попробуем применить ту же оптику к языкам программирования. Попробуем угадать язык по пяти строкам кода и заодно понять, по каким «ароматам» и «танинам» наш мозг так быстро их различает.

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

Есть особое удовольствие и свой шарм в слепой дегустации вина. Когда этикетка закрыта, остаются только цвет, аромат, текстура. Это, пожалуй, самая честная дегустация: вы ориентируетесь только на базовые «нравится»/«не нравится», «вкусно»/«невкусно». В моменте мозг продвинутого дегустатора лихорадочно сопоставляет: это Бургундия или Пьемонт, классика или Новый Свет? В конце концов, это красное или белое? (без шуток, если дегустировать некоторые вина в чёрных бокалах, определить белые они или красные, удаётся с огромным трудом).

С кодом происходит примерно то же самое. Дайте разработчику 5-7 строк, и он часто угадывает язык, потому что у каждого языка есть свой стиль, своя «органолептика» — синтаксис, ритм, плотность, любимые конструкции. Мы считываем их почти интуитивно.

В этой статье попробуем устроить слепую дегустацию кода: поиграть в угадайку, разобрать, по каким маркерам мозг узнает стиль, и аккуратно сравнить языки с разными стилями вина.

Раунд 1. Пять строк — и уже понятно

Начнём с простых примеров, где «букет» языка ощущается за секунды.

def normalize(text):
    words = text.lower().split()
    return [w.strip(".,!?") for w in words if w]

Согласитесь, Python считывается почти мгновенно. Почему?

В нём минимум шума: нет точек с запятой и фигурных скобок, читается как псевдокод, почти как английская фраза, list comprehension даёт плавность и ощущение цельности.

Если проводить винную аналогию, это что-то вроде Пино Нуара из Бургундии: визуально и даже по телу вино легкое, но с глубиной и интересными нюансами, все держится на балансе, а не на серьезной выдержке в дубе.

Поехали дальше! 

public static List<String> normalize(String text) {
    List<String> result = new ArrayList<>();
    for (String word : text.toLowerCase().split(" ")) {
        result.add(word.trim());
    }
    return result;
}

Конечно же, это Java. Его мы чувствуем по «телу» кода. Явные типы в сигнатуре и локальных переменных, строгая, почти архитектурная структура, много каркаса, который держит систему даже в простом примере.

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

const normalize = text =>
  text
    .toLowerCase()
    .split(" ")
    .map(w => w.trim())
    .filter(Boolean);

JavaScript мы с вами легко узнаем по стрелочным функциям, цепочкам методов, гибкости записи, которая считывается как в одной строке, так и в целой лесенке. 

Это вина Нового Света: яркие, сочные, ароматные, иногда чуть эклектичные и даже слегка вызывающие. Этот язык позволяет делать и аккуратные, выдержанные купажи, и довольно эксцентричные смеси, итог всегда в руках разработчика.

func normalize(text string) []string {
    words := strings.Fields(strings.ToLower(text))
    return words
}

Go — это чистота и прагматизм: минимум абстракций, четкие конструкции func, строгие типы, лаконичность и почти инженерный минимализм, ничего лишнего.

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

Как мозг «дегустирует» код?

Интереснее всего не угадывание, а сам процесс распознавания. На что мы опираемся, когда смотрим на незнакомый фрагмент?

Синтаксический аромат

Первый аромат бокала — это синтаксис: 

- фигурные скобки или отступы;

- ключевые слова (def, fn, func, public);

- типы в сигнатурах или их отсутствие;

- форма комментариев.

Мы моментально узнаем язык по нескольким токенам, как сомелье узнает стиль по первому вдоху: Python прозрачный, Java плотная, JavaScript ароматный и темпераментный, Go — строгий и честный.

Текстура и тело кода

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

- линейный или вложенный код;

- декларативный или императивный подход;

- плотность: много кода на одну мысль или мало.

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

Ритм и поток

Код тоже обладает ритмом. Где‑то вы читаете легко, будто знакомый рассказ, где‑то как технический регламент, где‑то как необузданный поток сознания. Python больше про повествование, Java про строгое следование правилам, JavaScript про импровизацию. С опытом вы начинаете чувствовать этот ритм так же уверенно, как отличаете игристое вино от выдержанного красного к стейкам.

Интерактив: угадай язык по пяти строкам

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

Задача 1

def compute(values):
    total = 0
    for v in values:
        if v is None:
            continue
        total += v
    return total or None

Варианты:

• A: JavaScript

• B: Python

• C: Ruby

• D: Go

Ответ: B: Python. Маркеры: def для объявления функции, отступы вместо фигурных скобок, None вместо null или nil. Это как тонкий аромат сорта: даже если вы не помните все детали, общие очертания узнаются.

Задача 2

result := make([]int, 0, len(values))
for _, v := range values {
    if v%2 == 0 {
        result = append(result, v)
    }
}
return result

Варианты:

• A: Go

• B: Rust

• C: TypeScript

• D: C#

Ответ: A: Go. Мозг цепляется за: короткое объявление :=, - range в for, - append и слайсы []int. Код сухой, ясный, без дополнительных украшений. Все как в классическом виноделии.

Задача 3

let normalize input =
    input
    |> String.lowercase_ascii
    |> String.split_on_char ' '
    |> List.filter (fun s -> s <> "")

Варианты:

• A: Elixir

• B: F#

• C: OCaml

• D: Scala

Ответ: C: OCaml. Маркеры: let для определения функции, оператор конвейера |>, модульные функции String.*, List.* и fun для лямбд. Функциональный стиль, но без перегруженности, как аккуратное, структурное вино из долины Луары.

Задача 4

public async Task<IEnumerable<User>> LoadUsersAsync(CancellationToken token)
{
    var users = await _repository.GetAllAsync(token);
    return users
        .Where(u => u.IsActive)
        .OrderBy(u => u.LastName)
        .ThenBy(u => u.FirstName);
}

Варианты:

• A: Java

• B: C#

• C: TypeScript

• D: Kotlin

Ответ: B: C#. Признаки — сочетание async/await в сигнатуре и теле, `` - Task> вместо Future> и т.п., ` - LINQ-стиль Where / OrderBy / ThenBy. Java и Kotlin выглядят иначе, TypeScript не использует Task<>`. Это выдержанный, структурный бордосский подход к корпоративному коду.

Задача 5

fn normalize(input: &str) -> Vec<&str> {
    input
        .to_lowercase()
        .split_whitespace()
        .collect()
}

Варианты:

• A: Rust

• B: Swift

• C: Kotlin

• D: Haskell

Ответ: A: Rust. Маркеры: - fn в объявлении, - заимствование &str и Vec, - цепочка методов с финальным .collect(). Сочетание строгой типизации и выразительной цепочки операций даёт ощущение вина с долгой выдержкой: сначала сложно, потом начинаешь улавливать всё больше и больше ароматики и нюансов. Вино раскрывается в бокале.

Винный погреб языков

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

Как в вине, у языков есть свои «старые винтажи».

Старый PHP с обилием HTML вперемешку с логикой — как полусладкое из 2000-х, с которого многие начинали знакомство с вином. Тогда казалось идеальным, сейчас вкусы стали более требовательными: хочется меньше сахара и больше структуры и гастрономичности.

Python 2 с print без скобок — это ностальгический ретро-винтаж из домашней коллекции. У кого-то стоит пара бутылок на полке на память, кто-то с теплотой вспоминает, но в актуальную винную карту (прод) его уже не ставят.

Ранний JavaScript времен тотального var и callback-пирамид — как ёмкость для сусла, где смешали все подряд. Формально это вино, но второй бокал берёшь с большой паузой и после пары крепких рефакторингов.

С опытом меняется вкус и на вино, и на язык: сначала хочется «сладкого» syntactic sugar и минимум типизации, потом начинаешь ценить сухость: строгие типы, явные контракты, предсказуемость, ещё позже приходишь к мысли, что разные стили нужны для разных задач. 

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