Почему программисты не стареют: эффект кодера после 40

Эта статья — не о вечной молодости и не про биохакинг. Это — живая техническая ретроспектива о том, почему некоторые программисты становятся сильнее с возрастом, а не наоборот. Как меняется восприятие кода после 40? Почему опытный разработчик способен «разруливать» архитектурные адские кухни там, где молодёжь сгорает на ревью? И при чём тут ассемблер, собаки и JavaScript? Ответы — внутри.

Сорок — это новые двадцать (в коде, по крайней мере)

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

Возраст — это баг или фича?

В любой профессии есть понятие «пика формы». У спортсменов — это лет до 30, у шахматистов — чуть дольше. А у программистов?

Если вы думаете, что в 45 уже «поздно», потому что невозможно «успевать за трендами», давайте для начала определимся, что такое тренды. React 19? AST-интерпретация в Rust? А теперь поднимите руку те, кто реально пишет AST вручную, не пользуясь библиотеками.

Вот пример простой задачи из системного программирования — парсинг ELF-файла в Linux:

// Пример на C: извлечение секций из ELF-файла
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <elf.h>

void print_elf_header(const char *filename) {
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    Elf64_Ehdr ehdr;
    read(fd, &ehdr, sizeof(ehdr));
    printf("Entry point: 0x%lx\n", ehdr.e_entry);
    close(fd);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <ELF-file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    print_elf_header(argv[1]);
    return 0;
}

Кто-то скажет: «Да это архаика». А по факту — это суть. Основы. И вот тут-то и начинается взрослая жизнь программиста.

Пример из жизни: «Молодые писали микросервисы, а он взял и всё удалил»

Проект. Команда. Микросервисы. Kubernetes. Пятьдесят конфигов и CI/CD, который не запускается с утра по понедельникам. И вот приходит один «старик» (ему 47), смотрит пару дней, потом говорит: «А давайте соберём это в один сервис на FastAPI». Ребята ржут. А через неделю — релиз. Без Docker Swarm. Без двух DevOps. И оно работает.

Вот пример из того самого FastAPI, чтобы не быть голословным:

# Пример на Python с FastAPI: упрощённый сервис
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    id: int
    name: str

db = {}

@app.post("/item/")
def create_item(item: Item):
    db[item.id] = item
    return {"message": "Item created"}

@app.get("/item/{item_id}")
def read_item(item_id: int):
    return db.get(item_id, {"message": "Item not found"})

Это не старость — это опыт. Когда ты уже видел слишком много проектов, чтобы верить в «архитектуру ради архитектуры».

Как меняется мышление после 40?

1. Меньше фреймворков — больше понимания.
   Вместо того чтобы тащить в проект модный пакет, зрелый разработчик сначала спросит себя: «А можно ли сделать это проще?»

2. Оптимизация времени, а не только памяти.
   С возрастом ты понимаешь, что код — это ещё и техподдержка. И что бывает больнее, чем плохо написанный алгоритм — например, плохо написанный onboarding.

3. Рефакторинг как стиль жизни.
   Раньше ты просто «фиксил баги». Теперь ты понимаешь: хороший код — это код, который легко читать спустя полгода.

Откуда берётся устойчивость?

Техническое старение в IT часто путают с профессиональным выгоранием. Но они не синонимы. Настоящее старение — это когда ты уже не хочешь учиться. А зрелость — когда ты учишься не из страха отстать, а из желания понять.

Вот пример на Rust — язык, который любят молодые, но осваивают не с первой попытки:

// Пример на Rust: базовая структура и матчинг
enum Command {
    Add(i32, i32),
    Sub(i32, i32),
}

fn execute(cmd: Command) -> i32 {
    match cmd {
        Command::Add(a, b) => a + b,
        Command::Sub(a, b) => a - b,
    }
}

fn main() {
    let result = execute(Command::Add(10, 5));
    println!("Result: {}", result);
}

Такой код легко объяснить, если ты преподавал. Или если ты уже разбирался с шаблонами в C++ десятилетие назад. Потому что паттерны повторяются. Меняются только синтаксисы.

Шутка напоследок (но не совсем)

— Почему ты больше не учишь новые фреймворки?
— Потому что я наконец-то понял старые.

Программирование как вино

После 40 ты не становишься медленнее. Ты становишься тише — и точнее. Ты тратишь меньше времени на беготню за хайпом и больше — на то, чтобы не плодить хаос. И в этом — особая ценность зрелых программистов.

Так что нет, программисты не стареют. Они эволюционируют!