Когда-то ты спорил на форумах о том, что лучше — tabs или spaces, а теперь просто настраиваешь .editorconfig и идешь пить кофе. Этот текст — не про карьеру, не про зарплаты и не про мотивацию. Это про то, как постепенно меняется восприятие кода, ответственности и хаоса, когда годы коммитов превращают энтузиазм в инженерное спокойствие. Здесь не будет морали — только наблюдения, немного иронии и чуть-чуть боли.

Вступление

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

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

Если хочешь — можешь искать себя в этих стадиях. Только без самоиронии будет скучно.

Энтузиаст

Тот самый момент, когда ты впервые запускаешь hello world и чувствуешь, что только что построил Вселенную. Любой код кажется искусством. Любая строчка — откровением. Ты не думаешь о сложности алгоритма, просто радуешься, что что-то заработало.

На этом этапе код пахнет свободой и отсутствием здравого смысла. Я помню, как писал мини-движок на JavaScript без единого понимания событийного цикла. Всё было в одном файле, зато — работало же!

// язык: JavaScript
let users = [];
function addUser(name) {
  users.push(name);
  render();
}

function render() {
  const list = document.getElementById('users');
  list.innerHTML = '';
  users.forEach(u => {
    const li = document.createElement('li');
    li.innerText = u;
    list.appendChild(li);
  });
}

document.getElementById('add').onclick = () => {
  const name = document.getElementById('name').value;
  addUser(name);
};

Через пару недель ты узнаешь, что DOM-операции внутри цикла — это боль. Но тогда ты ещё не знаешь слова «оптимизация». Ты просто кайфуешь от самого факта, что можешь создавать.

Ремесленник

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

Ремесленник впервые понимает, что архитектура — не абстракция, а конкретное количество бессонных ночей. Появляются логи, тесты, CI/CD, но пока всё ещё вперемешку.
Ты уже знаешь, что монолит — зло, но не до конца понимаешь, почему микросервисы — не спасение.

// язык: Go
func processOrder(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Processing order %d\n", id)
    time.Sleep(time.Second)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go processOrder(i, &wg)
    }
    wg.Wait()
    fmt.Println("All orders processed")
}

Тебе кажется, что ты покорил параллелизм, пока не встретишь race conditions и не потратишь два дня, объясняя QA, почему «иногда падает».

Архитектор-прагматик

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

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

# язык: Python
from fastapi import FastAPI, Depends
from pydantic import BaseModel

class Order(BaseModel):
    id: int
    total: float

def get_discount(order: Order) -> float:
    if order.total > 1000:
        return order.total * 0.1
    return 0.0

app = FastAPI()

@app.post("/order")
def create_order(order: Order):
    discount = get_discount(order)
    return {"order_id": order.id, "discount": discount}

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

Наставник

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

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

Но наставник без кодовой практики быстро превращается в лектора. Поэтому ты всё ещё дебажишь, пусть и меньше.

Архитектор-отшельник

Это не стадия гордыни, а стадия тишины. Когда ты больше не хочешь доказывать. Ты проектируешь систему, как садовник — растишь архитектуру, убираешь сорняки, следишь за балансом.

Всё становится проще и одновременно глубже. Каждый новый сервис — это не гордость, а ответственность.

Ты перестаешь гнаться за хайпом, потому что знаешь: настоящий вызов — не придумать, а поддерживать.

// язык: Rust
use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let data = Arc::new(Mutex::new(vec![]));
    let mut handles = vec![];

    for i in 0..10 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut v = data.lock().unwrap();
            v.push(i);
        });
        handles.push(handle);
    }

    for h in handles {
        h.join().unwrap();
    }

    println!("Final data: {:?}", *data.lock().unwrap());
}

Теперь тебе интересны не языки, а принципы: изоляция, предсказуемость, отказоустойчивость. Всё остальное — детали реализации.

Послесловие

Если на какой-то стадии ты себя узнал — значит, движешься. Нет правильного темпа. У кого-то это занимает годы, у кого-то — десятилетие. Главное, чтобы путь не превратился в конвейер.

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