Куда двигаться дальше: специализации, план обучения и первая работа

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

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

Что вы уже умеете (и это больше, чем кажется)

Пройдёмся по списку. Если про пункт вы думаете «а, ну это я помню примерно» — это нормально, знание закрепляется практикой, а не чтением.

• Как работает компьютер и интернет — биты, память, процессор, клиент и сервер, HTTP (01, 02).
• Пять кирпичиков любой программы — данные, последовательность, условие, повторение, функция (04–07).
• Структуры данных — списки, словари, множества (08).
• Работа с внешним миром — файлы, CSV, JSON (09).
• Отладка — читать traceback, а не пугаться его (10).
• Инструменты — терминал и Git (12).

Давайте это измерим — честно, для себя. Вот программа-самопроверка; поставьте свои оценки от 1 (не помню совсем) до 5 (могу объяснить другому человеку без подсказок).

# Словарь: ключ — тема, значение — ваша оценка от 1 до 5.
# Замените числа на свои — честно, без «ну наверное 4».
navyki = {
    "переменные и типы": 4,
    "условия": 4,
    "циклы": 3,
    "функции": 3,
    "списки и словари": 3,
    "файлы и JSON": 2,
    "чтение ошибок": 3,
    "git": 2,
}

slabye = []                              # сюда сложим темы с низкой оценкой
for tema, ocenka in navyki.items():      # .items() даёт пары «ключ, значение»
    if ocenka <= 2:                      # 1 и 2 — то, что реально проседает
        slabye.append(tema)

srednee = sum(navyki.values()) / len(navyki)   # сумма оценок / их количество

print(f"Средняя уверенность: {srednee:.1f} из 5")   # :.1f — один знак после запятой
print("Подтянуть в первую очередь:", ", ".join(slabye))

Что выведет этот код с числами из примера:

Средняя уверенность: 3.0 из 5
Подтянуть в первую очередь: файлы и JSON, git

Правило простое: не начинайте новую большую тему, пока в списке slabye есть что-то из базы. Дыры в фундаменте не зарастают сами, они просто становятся дороже.

Карта специализаций

«Программист» — это не профессия, а класс профессий, как «врач». Вот основные направления и что за ними стоит.

Коротко и без рекламы, чем они отличаются на практике:

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

Как выбрать одно направление

Самая частая ошибка на этом этапе — выбирать по зарплатным вилкам из статей. Вилки меняются, а год вашей жизни потрачен один раз. Работают три критерия, в таком порядке.

1. Интерес, проверенный руками. Не «мне кажется, фронтенд интереснее», а «я три вечера подряд не мог оторваться». Чтобы это проверить, нужен эксперимент: две недели на каждого кандидата, крошечный проект в конце. Две недели — это мало для навыка, но достаточно, чтобы понять, тошнит вас от этого или нет.
2. Рынок. Откройте любой сайт вакансий, отфильтруйте «junior» и ваш город (или «удалённо»), посмотрите, сколько объявлений. Двадцать вакансий и две — очень разные истории.
3. Ваш прошлый опыт. Он не обнуляется. Бухгалтер быстрее входит в финтех, учитель — в образовательные продукты, врач — в медицинские системы. Знание предметной области — это реальное конкурентное преимущество, а не отговорка.

И правило, которое спасает: выбрали — не меняете 6–9 месяцев. Метания между направлениями — главный пожиратель времени у новичков. Любое из направлений выше даёт работу; ни одно не даёт её за три месяца перескоков.

Ширина и глубина: почему нельзя учить всё

Полезная модель — «T-образный специалист». Горизонтальная перекладина буквы T — общая база, которая нужна всем; вертикальная ножка — глубина в одном деле.

Перекладина у вас уже частично есть — этот курс её и строил. Ножку придётся растить осознанно и долго. Человек с одной ножкой находит работу; человек с пятью зачатками ножек не находит ничего, хотя суммарно потратил больше времени.

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

План на 6–9 месяцев

Дальше — пример плана для самого массового варианта: бэкенд на Python. Для другого направления структура та же, меняется содержание блоков.

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

Рабочий цикл обучения выглядит так:

Пунктирная стрелка — это tutorial hell, «туториальный ад»: состояние, когда человек бесконечно проходит курсы, потому что там всегда понятно и не страшно, а свой проект — страшно и непонятно. Симптом простой: за месяц пройдено три курса и не написано ни строчки собственного кода. Лечение — начать делать до того, как почувствуете себя готовым. Готовым вы себя не почувствуете; это не ваша особенность, это норма.

Про портфолио: что считается проектом

Проект — это программа, которая решает чью-то задачу и запускается у другого человека. Не «повторил за видео». Хватает трёх.

1. Учебный клон. Знакомая вещь, сделанная руками: сокращатель ссылок, список задач, простой блог. Цель — пройти весь путь целиком, включая скучные части.
2. Своя идея. Что-то, что нужно лично вам: трекер расходов, бот, который присылает расписание, скрипт для вашей прошлой работы. Такие проекты вы доделываете, потому что сами ими пользуетесь.
3. Проект с чужими данными. Приложение, которое берёт данные из внешнего источника (открытый API, выгрузка CSV) и что-то с ними делает. Показывает, что вы умеете работать с реальностью, а не с идеальными учебными данными.

К каждому проекту — README (файл с описанием в корне репозитория, читается прямо на странице проекта в GitHub): что делает, зачем, как запустить, скриншот или пример вывода. Часто README читают внимательнее, чем код. Проект без README для многих просто не существует.

Пример структуры README, которую можно скопировать:

# Трекер расходов

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

## Как запустить
    git clone https://github.com/user/rashody.git
    cd rashody
    python main.py

## Что умеет
- добавить трату: сумма, категория, дата
- отчёт за месяц по категориям
- экспорт в CSV

## Что дальше
Хочу добавить графики и хранение в SQLite.

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

Новый этап — новые ошибки: чужой код и библиотеки

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

Библиотека (или пакет, или модуль) — чужой код, который вы подключаете к своей программе, чтобы не писать всё с нуля. Подключается строкой import.

import requests   # библиотека для запросов к сайтам, в Python не встроена

Запускаете — и получаете:

Traceback (most recent call last):
  File "/home/user/proekt/main.py", line 1, in <module>
    import requests
ModuleNotFoundError: No module named 'requests'

Дословно: «Ошибка «модуль не найден»: нет модуля с именем requests». Python поискал такую библиотеку у себя и не нашёл. Это не значит, что вы неправильно написали код — просто библиотека не установлена. Ставится она через pip — программу-установщик, которая приходит вместе с Python:

pip install requests

Вторая ошибка, с которой сталкиваются почти все на Linux и macOS:

error: externally-managed-environment
× This environment is externally managed

Дословно: «окружение управляется извне». Смысл: вы пытаетесь ставить пакеты в тот Python, которым пользуется сама операционная система, и она защищается, чтобы вы её не сломали. Правильный ответ — виртуальное окружение: отдельная папка со своей копией Python и своими библиотеками, привязанная к одному проекту.

python3 -m venv .venv          # создать окружение в папке .venv внутри проекта
source .venv/bin/activate      # включить его (Windows: .venv\Scripts\activate)
pip install requests           # теперь пакет ставится внутрь проекта, а не в систему

После activate в начале строки терминала появится (.venv) — признак, что окружение включено. Аналогия: виртуальное окружение — это отдельный ящик с инструментами для одного ремонта, вместо общей свалки инструментов в квартире. Где аналогия ломается: ящик не копирует инструменты физически, а Python-окружение действительно держит свои копии библиотек — поэтому два проекта могут спокойно использовать разные версии одной библиотеки.

Папку .venv не кладут в Git — добавьте её в .gitignore. Вместо этого фиксируют список пакетов:

pip freeze > requirements.txt   # записать список установленных пакетов в файл
pip install -r requirements.txt # восстановить их на другом компьютере

Первая работа: как это выглядит на самом деле

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

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

Жизненный цикл одного отклика:

Чтобы всё это не превратилось в кашу, отклики стоит записывать. Заодно это отличный маленький проект — он использует ровно то, что вы уже знаете: словари, списки, функции и JSON.

import json
import os

FAYL = "otkliki.json"                    # имя файла, где храним данные

def zagruzit():
    """Прочитать список откликов из файла. Если файла нет — вернуть пустой список."""
    if not os.path.exists(FAYL):         # os.path.exists проверяет, есть ли файл
        return []
    with open(FAYL, encoding="utf-8") as f:
        return json.load(f)              # json.load превращает текст файла в список

def sohranit(otkliki):
    """Записать список откликов обратно в файл."""
    with open(FAYL, "w", encoding="utf-8") as f:
        # ensure_ascii=False — чтобы русские буквы остались буквами, а не р
        json.dump(otkliki, f, ensure_ascii=False, indent=2)

def dobavit(otkliki, kompaniya, vakansiya):
    """Добавить новый отклик со стартовым статусом."""
    otkliki.append({
        "компания": kompaniya,
        "вакансия": vakansiya,
        "статус": "отправлен",
    })

def statistika(otkliki):
    """Посчитать, сколько откликов в каждом статусе."""
    schetchik = {}
    for o in otkliki:
        status = o["статус"]
        # .get(status, 0) — «взять текущее число или 0, если такого ключа ещё нет»
        schetchik[status] = schetchik.get(status, 0) + 1
    return schetchik

otkliki = zagruzit()
dobavit(otkliki, "Ромашка", "Python-разработчик (junior)")
dobavit(otkliki, "Кактус", "Стажёр-бэкендер")
otkliki[0]["статус"] = "скрининг"        # первый отклик продвинулся дальше
sohranit(otkliki)

print(f"Всего откликов: {len(otkliki)}")
for status, kolichestvo in statistika(otkliki).items():
    print(f"  {status}: {kolichestvo}")

Вывод при первом запуске:

Всего откликов: 2
  скрининг: 1
  отправлен: 1

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

Про технические собеседования

На junior-собеседовании проверяют три вещи, и только одна из них — знание синтаксиса.

1. База. Чем список отличается от словаря, что такое функция, что делает цикл, что такое HTTP-запрос. Спрашивают простыми словами и ждут простых слов в ответ.
2. Умение думать вслух. Дают маленькую задачу и смотрят не на идеальное решение, а на ход мысли. Молчаливое правильное решение ценится ниже, чем проговорённое приблизительное.
3. Ваши проекты. «Почему сделали так?», «что бы переделали?», «что было сложнее всего?». Поэтому проекты должны быть свои — про чужой код рассказать нечего.

Типичная задача уровня входа выглядит примерно так: «найди три самых частых слова в тексте».

def top_slova(tekst, skolko=3):
    """Вернуть список пар (слово, сколько раз встретилось), самые частые — первыми."""
    schetchik = {}
    for slovo in tekst.lower().split():      # .lower() — в нижний регистр, .split() — разбить по пробелам
        slovo = slovo.strip(".,!?;:()\"'")   # .strip(...) убирает знаки препинания по краям
        if not slovo:                        # если после чистки осталась пустая строка — пропускаем
            continue
        schetchik[slovo] = schetchik.get(slovo, 0) + 1

    # sorted сортирует; key говорит, по какому признаку.
    # lambda para: para[1] — короткая безымянная функция «взять второй элемент пары», то есть счётчик.
    pary = sorted(schetchik.items(), key=lambda para: para[1], reverse=True)
    return pary[:skolko]                     # срез: первые `skolko` штук

tekst = "Код читают чаще, чем пишут. Поэтому код пишут для людей, а не для машин."
print(top_slova(tekst))

Вывод:

[('код', 2), ('пишут', 2), ('для', 2)]

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

Типичные ошибки на этом этапе

• Учить всё сразу. Python, JavaScript и Go одновременно — это ноль языков через полгода.
• Ждать «готовности». Ощущения «я готов» не наступит. Откликаться нужно, когда есть два-три своих проекта и вы можете про них рассказать, а не когда пропадёт страх.
• Читать вакансию как список требований. Вакансия — это список пожеланий, часто написанный «на вырост». Соответствие на 60 % — нормальный повод откликнуться.
• Врать в резюме. Не про этику, а про практику: приписанный опыт разваливается на первом же техническом вопросе, и дальше разговора не будет.
• Принимать отказ на свой счёт. Отказ на 90 % — про поток кандидатов, бюджет и случайность, и на 10 % — про вас. Полезен только тот отказ, к которому приложена обратная связь.
• Учиться в одиночку. Сообщество (чат, локальный митап, open source) даёт то, чего не даёт ни один курс: живые примеры чужого кода и ощущение, что вы не один такой.
• Бросать код после трудоустройства. Первый год на работе — самый быстрый рост в жизни, но только если продолжать разбираться, а не отсиживать задачи.

Практика

От простого к сложному. Первое можно сделать за вечер, последнее растянется на недели.

1. Честная самооценка. Возьмите программу из первого раздела, замените оценки на свои и запустите. Выпишите три темы с самыми низкими баллами и на каждую напишите по маленькой программе на 10–20 строк, не подсматривая в статьи курса. Подсказка: «не подсматривая» — ключевое условие. Подсмотрели — тема не закрыта.

2. Двухнедельный эксперимент. Выберите два направления-кандидата. На каждое — по неделе и по крошечному проекту в конце (например, для фронтенда — страница с кнопкой, меняющей текст; для бэкенда — скрипт, который читает CSV и печатает отчёт). В конце запишите в файл vybor.md, что понравилось и что раздражало. Подсказка: сравнивайте не результат, а ощущение от процесса — работать вам предстоит именно в процессе.

3. Улучшите трекер откликов. Возьмите программу из раздела про поиск работы и добавьте: (а) проверку, что такая компания и вакансия ещё не добавлены; (б) функцию izmenit_status, которая находит отклик по названию компании и меняет статус; (в) вывод только тех откликов, которые «висят» дольше двух недель. Подсказка для (в): дату сохраняйте строкой "2026-08-01" — такие строки корректно сравниваются оператором <, потому что год идёт первым. Для «сегодня» пригодится datetime.date.today().isoformat().

4. README к старому проекту. Возьмите любую программу, которую писали по ходу курса, положите её в отдельный репозиторий на GitHub и напишите README по структуре из статьи. Затем дайте прочитать человеку, далёкому от программирования, и спросите: понятно ли, что делает программа и как её запустить. Подсказка: если человек задал вопрос — это не его проблема, а дырка в README.

5. План на 6 месяцев в виде программы. Напишите скрипт, который хранит список этапов (название, сколько недель, статус) в JSON и печатает: сколько недель занимает план целиком, какой этап идёт сейчас и сколько процентов пути пройдено. Обновляйте его раз в неделю — это и практика, и дисциплина. Подсказка: проценты считаются как «завершённые недели / все недели * 100»; для красивого вывода пригодится f"{procent:.0f}%".

Мини-итог

• Базовый курс даёт не профессию, а способность учиться самостоятельно — и это правильный результат, а не недостача.
• Направлений много; выбирать нужно одно, проверив его руками, а не по зарплатным обзорам. ML и DevOps почти никогда не бывают первой работой — это про статистику вакансий, не про вашу способность.
• Модель «широкая база + одна глубина» работает; пять недоделанных специализаций — нет.
• Проекты идут параллельно обучению, а не после. Свой проект, которым вы пользуетесь сами, сильнее десяти повторённых за видео.
• Поиск первой работы — воронка из десятков откликов. Отказы обезличены и почти никогда не про вас лично.
• На собеседовании смотрят на ход мысли и на ваши проекты не меньше, чем на знание синтаксиса.
• Библиотеки ставятся через pip в виртуальное окружение — ModuleNotFoundError означает «пакет не установлен», а не «вы написали неправильный код».

Что дальше

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

Если выбрали язык и хотите углубиться: Go — простой и востребованный в бэкенде; TypeScript — если тянет во фронтенд; C# — большой корпоративный мир; Elixir — если интересны необычные подходы.

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

Если тянет в данные или продукт: Инженерия данных, Машинное обучение, Продуктовый менеджмент или Управление проектами.

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

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

Спасибо, что дошли до конца. Дальше начинается настоящее — и оно интереснее курса.