Системный подход к вайбкодингу: анализ, дизайн и запуск веб-приложения 26 Sections288 Lessons25 QuizzesСрок службы
- 26 Sections
- 288 Lessons
- Срок службы
Развернуть все разделыСвернуть все разделы
- 0. Прежде чем начать9 Items
- 1.1RT1Y 0.1 Что такое вайбкодинг и откуда взялось слово
- 1.2RT1Y 0.2 Что вы построите к концу курса
- 1.3RT1Y 0.3 Как устроен этот курс и как по нему идти
- 1.4RT1Y 0.4 Что понадобится — программы, доступы и деньги
- 1.5RT1Y 0.5 Сколько времени это займёт
- 1.6RT1Y 0.6 Что обычно идёт не так
- 1.7RT1Y 0.7 Почему системный подход, а не набор промптов
- 1.8RT1Y 0.8 Как работать в петле и вести записи
- 1.9RT1Y 0.9 Кому курс не подойдёт
- 1. Что может пойти не так с вайбкодингом?10 Items
- 2.1RT1Y 1.1 Как проект скатывается в бесконечные правки
- 2.2RT1Y 1.2 Что на самом деле делает ИИ-агент
- 2.3RT1Y 1.3 Почему агент уверенно сообщает неправду
- 2.4RT1Y 1.4 Цена размытой задачи и неясных границ
- 2.5RT1Y 1.5 Петля спека → генерация → проверка → откат
- 2.6RT1Y 1.6 Три роли человека рядом с агентом
- 2.7RT1Y 1.7 Где подход работает, а где нужен разработчик
- 2.8RT1Y 1.8 Выбор своей предметной области для курса
- 2.9RT1Y 1.9 Как описать идею проекта в свободной форме
- 2.10RT1Y 1 Итоговый тест5 Questions
- 2. Из чего состоит приложение: базовая техграмотность15 Items
- 3.1RT1Y 2.1 Что происходит после клика по кнопке
- 3.2RT1Y 2.2 Браузер, клиент и сервер без технического тумана
- 3.3RT1Y 2.3 Почему приложение почти всегда делится надвое
- 3.4RT1Y 2.4 Что делает фронтенд и где кончается его зона
- 3.5RT1Y 2.5 Что делает бэкенд и за что он отвечает
- 3.6RT1Y 2.6 Почему языков программирования так много
- 3.7RT1Y 2.7 Зачем в курсе выбран Python
- 3.8RT1Y 2.8 Библиотека, пакет и зависимость простыми словами
- 3.9RT1Y 2.9 Фреймворк и чем он отличается от библиотеки
- 3.10RT1Y 2.10 Что такое FastAPI и что он берёт на себя
- 3.11RT1Y 2.11 HTTP — запрос, ответ и методы без магии
- 3.12RT1Y 2.12 Что означают коды 200, 404 и 500
- 3.13RT1Y 2.13 API, эндпоинт и JSON на примере записи
- 3.14RT1Y 2.14 Кто первым встречает пользователя у входа
- 3.15RT1Y 2 Итоговый тест5 Questions
- 3. Где живут данные: базы, кэш и файлы14 Items
- 4.1RT1Y 3.1 Зачем приложению база, а не таблица в Excel
- 4.2RT1Y 3.2 Таблицы, строки и связи на понятном примере
- 4.3RT1Y 3.3 SQL как язык вопросов к данным
- 4.4RT1Y 3.4 Почему в курсе используется PostgreSQL
- 4.5RT1Y 3.5 Когда данные не помещаются в строгие таблицы
- 4.6RT1Y 3.6 Документная база — что в ней удобно и что нет
- 4.7RT1Y 3.7 Хранилище ключ-значение и зачем нужен кэш
- 4.8RT1Y 3.8 Когда обычный поиск перестаёт справляться
- 4.9RT1Y 3.9 Где хранить картинки, документы и вложения
- 4.10RT1Y 3.10 Как выбрать базу без лишней драмы
- 4.11RT1Y 3.11 Транзакция — почему операция должна быть целой
- 4.12RT1Y 3.12 Индекс — откуда берётся ускорение и тормоза
- 4.13RT1Y 3.13 Резервные копии как часть устройства системы
- 4.14RT1Y 3 Итоговый тест5 Questions
- 4. Как части приложения общаются: очереди, брокеры и фоновые задачи12 Items
- 5.1RT1Y 4.1 Сразу или потом — два способа делать работу
- 5.2RT1Y 4.2 Какие операции нельзя держать в ожидании экрана
- 5.3RT1Y 4.3 Очередь задач на бытовом примере
- 5.4RT1Y 4.4 Что делает брокер сообщений между частями системы
- 5.5RT1Y 4.5 RabbitMQ — когда нужен простой обмен задачами
- 5.6RT1Y 4.6 Kafka — когда важен поток событий, а не очередь
- 5.7RT1Y 4.7 Фоновая отправка письма и напоминания о записи
- 5.8RT1Y 4.8 Задачи по расписанию и регулярные операции
- 5.9RT1Y 4.9 Вебхук — когда внешний сервис сам приходит к вам
- 5.10RT1Y 4.10 Потерянные и задвоенные сообщения — как это выглядит
- 5.11RT1Y 4.11 Когда брокер только мешает и усложняет проект
- 5.12RT1Y 4 Итоговый тест5 Questions
- 5. Терминал, файлы и умение читать ошибки12 Items
- 6.1RT1Y 5.1 Что такое терминал и зачем он нужен в курсе
- 6.2RT1Y 5.2 Что в терминале делать безопасно, а что нет
- 6.3RT1Y 5.3 Путь, папка и текущий каталог без путаницы
- 6.4RT1Y 5.4 Как перемещаться по папкам и не потеряться
- 6.5RT1Y 5.5 Как читать команду до её запуска
- 6.6RT1Y 5.6 Аргумент и флаг — что меняет поведение команды
- 6.7RT1Y 5.7 Красный текст на экране — как не пугаться
- 6.8RT1Y 5.8 Как найти настоящую причину в сообщении об ошибке
- 6.9RT1Y 5.9 Стектрейс и лог — где искать полезную часть
- 6.10RT1Y 5.10 Что делать, если ничего не происходит
- 6.11RT1Y 5.11 Как искать причину по одному изменению за раз
- 6.12RT1Y 5 Итоговый тест5 Questions
- 6. Docker и запуск проекта на своём компьютере13 Items
- 7.1RT1Y 6.1 Зачем Docker нужен непрограммисту
- 7.2RT1Y 6.2 Почему он снимает проблему ‘у меня работает’
- 7.3RT1Y 6.3 Образ и контейнер на бытовых аналогиях
- 7.4RT1Y 6.4 Слой, том и порт без технической каши
- 7.5RT1Y 6.5 Установка Docker — что проверить после запуска
- 7.6RT1Y 6.6 Откуда брать стартовый репозиторий курса
- 7.7RT1Y 6.7 Dockerfile — из чего собирается приложение
- 7.8RT1Y 6.8 Docker Compose — несколько сервисов одной командой
- 7.9RT1Y 6.9 Файл .env и настройки отдельно от кода
- 7.10RT1Y 6.10 Запуск проекта командой make up
- 7.11RT1Y 6.11 Что делать при проблемах с реестрами из России
- 7.12RT1Y 6.12 Типовые поломки запуска и как их распознать
- 7.13RT1Y 6 Итоговый тест5 Questions
- 7. Git как страховка от необратимого14 Items
- 8.1RT1Y 7.1 Зачем Git тому, кто не пишет код руками
- 8.2RT1Y 7.2 Коммит как точка сохранения проекта
- 8.3RT1Y 7.3 Почему маленький коммит лучше большого
- 8.4RT1Y 7.4 Диф — как увидеть, что именно поменял агент
- 8.5RT1Y 7.5 Ветка под каждую задачу и зачем это вам
- 8.6RT1Y 7.6 Слияние веток без паники
- 8.7RT1Y 7.7 Конфликт при слиянии — как понять, что произошло
- 8.8RT1Y 7.8 Revert — безопасный откат уже внесённых изменений
- 8.9RT1Y 7.9 Reset — чем он отличается и почему опасен
- 8.10RT1Y 7.10 Как вернуть то, что кажется потерянным
- 8.11RT1Y 7.11 Что не должно попадать в репозиторий никогда
- 8.12RT1Y 7.12 Pull request как единица приёмки работы агента
- 8.13RT1Y 7.13 Где хранить репозиторий, работая из России
- 8.14RT1Y 7 Итоговый тест5 Questions
- 8. Анализ: требования и границы системы9 Items
- 9.1RT1Y 8.1 Почему ‘я примерно знаю, что хочу’ не работает
- 9.2RT1Y 8.2 Какие вопросы задать заказчику или самому себе
- 9.3RT1Y 8.3 Как вытащить скрытые умолчания из разговора
- 9.4RT1Y 8.4 Требование и готовое решение — как их не путать
- 9.5RT1Y 8.5 Что входит в границы системы, а что нет
- 9.6RT1Y 8.6 Внешние участники и их интерес к системе
- 9.7RT1Y 8.7 Контекстная диаграмма на одном листе
- 9.8RT1Y 8.8 Как зафиксировать требования в проверяемом виде
- 9.9RT1Y 8 Итоговый тест0 Questions
- 9. Анализ: роли и сценарии9 Items
- 10.1RT1Y 9.1 Кто пользуется системой и чем роли отличаются
- 10.2RT1Y 9.2 Как описать основную цель каждой роли
- 10.3RT1Y 9.3 Основной сценарий — путь от входа до результата
- 10.4RT1Y 9.4 Как расписывать шаги сценария без двусмысленности
- 10.5RT1Y 9.5 Альтернативные потоки — когда пользователь идёт иначе
- 10.6RT1Y 9.6 Ошибки и исключения как часть сценария
- 10.7RT1Y 9.7 Кто что видит и кто что может менять
- 10.8RT1Y 9.8 Как проверить сценарии на полноту до кода
- 10.9RT1Y 9 Итоговый тест5 Questions
- 10. Анализ: домен, данные и состояния11 Items
- 11.1RT1Y 10.1 Глоссарий — одно слово — один смысл
- 11.2RT1Y 10.2 Сущности проекта на примере сервиса записи
- 11.3RT1Y 10.3 Атрибуты — какие данные реально нужны сущности
- 11.4RT1Y 10.4 Связи между сущностями и что они меняют
- 11.5RT1Y 10.5 Один-ко-многим и другие важные отношения
- 11.6RT1Y 10.6 Доменная модель — как собрать картину целиком
- 11.7RT1Y 10.7 Как проверить, что модель не врёт о реальности
- 11.8RT1Y 10.8 Состояния записи — создана, подтверждена, отменена
- 11.9RT1Y 10.9 Запрещённые переходы и почему они важны
- 11.10RT1Y 10.10 Типовые ошибки моделирования и их цена
- 11.11RT1Y 10 Итоговый тест5 Questions
- 11. Анализ: правила, ограничения и критерии приёмки10 Items
- 12.1RT1Y 11.1 Бизнес-правила — что в системе нельзя нарушать
- 12.2RT1Y 11.2 Инварианты — правила, которые должны держаться всегда
- 12.3RT1Y 11.3 Скорость, надёжность и объём без технического тумана
- 12.4RT1Y 11.4 Нефункциональные требования простым языком
- 12.5RT1Y 11.5 Как записать критерий приёмки так, чтобы проверить
- 12.6RT1Y 11.6 Чем ‘работает’ отличается от ‘кажется, работает’
- 12.7RT1Y 11.7 Как найти дыры и противоречия в собственной модели
- 12.8RT1Y 11.8 Что делать с конфликтующими требованиями
- 12.9RT1Y 11.9 Как выглядит готовый пакет аналитики для агента
- 12.10RT1Y 11 Итоговый тест5 Questions
- 12. Системное мышление: видеть приложение целиком12 Items
- 13.1RT1Y 12.1 Что такое система и зачем вам это мышление
- 13.2RT1Y 12.2 Почему целое ведёт себя не как сумма частей
- 13.3RT1Y 12.3 Потоки данных от рождения до удаления
- 13.4RT1Y 12.4 Карта системы — как уместить приложение на листе
- 13.5RT1Y 12.5 Как держать карту системы в актуальном состоянии
- 13.6RT1Y 12.6 Радиус поражения — что сломается от одной правки
- 13.7RT1Y 12.7 Почему одна правка тянет за собой десять
- 13.8RT1Y 12.8 Удобная фича, которая создаёт новую нагрузку
- 13.9RT1Y 12.9 Когда метрика начинает портить продукт
- 13.10RT1Y 12.10 Откуда растёт сложность и как её не плодить
- 13.11RT1Y 12.11 Как временный костыль становится архитектурой
- 13.12RT1Y 12 Итоговый тест5 Questions
- 13. Системный дизайн: части, границы и контракты14 Items
- 14.1RT1Y 13.1 Как перейти от доменной модели к устройству системы
- 14.2RT1Y 13.2 По какому шву делить приложение на части
- 14.3RT1Y 13.3 Почему файл на 3000 строк лишает вас контроля
- 14.4RT1Y 13.4 Что такое контракт между частями приложения
- 14.5RT1Y 13.5 Как понять хороший контракт без программирования
- 14.6RT1Y 13.6 Почему чёткие границы важны для работы с агентом
- 14.7RT1Y 13.7 Простота против гибкости — выбор с последствиями
- 14.8RT1Y 13.8 Скорость против надёжности на реальном примере
- 14.9RT1Y 13.9 Как записывать цену решения вслух и письменно
- 14.10RT1Y 13.10 Зачем нужен журнал решений и отвергнутых вариантов
- 14.11RT1Y 13.11 Оценка размеров системы без точных расчётов
- 14.12RT1Y 13.12 Где решение обратимо, а где ошибаться дорого
- 14.13RT1Y 13.13 Как понять, что систему пора менять
- 14.14RT1Y 13 Итоговый тест5 Questions
- 14. Системный дизайн: время, одновременность и отказы13 Items
- 15.1RT1Y 14.1 Две записи на один слот — где рождается конфликт
- 15.2RT1Y 14.2 Конкуренция за ресурс без сложных терминов
- 15.3RT1Y 14.3 Что делать, если кнопку нажали дважды
- 15.4RT1Y 14.4 Идемпотентность на примере записи и оплаты
- 15.5RT1Y 14.5 Почему операция должна пройти целиком
- 15.6RT1Y 14.6 Время и часовые пояса — тихие и дорогие ошибки
- 15.7RT1Y 14.7 Расписание и календарь — где ломается логика
- 15.8RT1Y 14.8 Внешний сервис недоступен — таймаут и повтор
- 15.9RT1Y 14.9 Деградация вместо полного отказа
- 15.10RT1Y 14.10 Частичный отказ — одна часть сработала, другая нет
- 15.11RT1Y 14.11 Наблюдаемость как часть проекта с самого начала
- 15.12RT1Y 14.12 Что логировать, чтобы потом найти причину
- 15.13RT1Y 14 Итоговый тест5 Questions
- 15. Spec-driven development11 Items
- 16.1RT1Y 15.1 Почему спека важнее устных договорённостей
- 16.2RT1Y 15.2 Спека как исходный код проекта
- 16.3RT1Y 15.3 Продуктовая спека — что строим и для кого
- 16.4RT1Y 15.4 Функциональная спека — как работает отдельная часть
- 16.5RT1Y 15.5 Задача — самый маленький рабочий уровень спеки
- 16.6RT1Y 15.6 Формат спеки, понятный человеку и модели
- 16.7RT1Y 15.7 Как связать требование, задачу, тест и коммит
- 16.8RT1Y 15.8 Почему спека должна жить в репозитории
- 16.9RT1Y 15.9 Что происходит, когда код и спека расходятся
- 16.10RT1Y 15.10 Как из спеки появляется бэклог задач
- 16.11RT1Y 15 Итоговый тест5 Questions
- 16. Архитектура, данные и миграции13 Items
- 17.1RT1Y 16.1 Монолит со слоями — почему это разумный старт
- 17.2RT1Y 16.2 Что лежит в app/domain и зачем это выделять
- 17.3RT1Y 16.3 Что лежит в app/application и чем слой полезен
- 17.4RT1Y 16.4 Что лежит в app/infrastructure и app/interface
- 17.5RT1Y 16.5 Как ориентироваться в структуре репозитория курса
- 17.6RT1Y 16.6 Почему в курсе выбран именно этот стек
- 17.7RT1Y 16.7 Как доменная модель превращается в схему базы
- 17.8RT1Y 16.8 Что такое миграция и почему без неё опасно
- 17.9RT1Y 16.9 Как выполнять миграции командой make migrate
- 17.10RT1Y 16.10 Настройки из окружения и файл .env.example
- 17.11RT1Y 16.11 API-контракт в письменном виде
- 17.12RT1Y 16.12 Архитектура как способ сжать контекст для агента
- 17.13RT1Y 16 Итоговый тест5 Questions
- 17. Проектирование экранов11 Items
- 18.1RT1Y 17.1 Как сценарий превращается в экран
- 18.2RT1Y 17.2 Какие экраны нужны сервису записи на старте
- 18.3RT1Y 17.3 Состояние загрузки — что видит человек в ожидании
- 18.4RT1Y 17.4 Пустой экран, ошибка и успех как отдельные случаи
- 18.5RT1Y 17.5 Формы — как человек вводит данные без боли
- 18.6RT1Y 17.6 Валидация и подсказки до отправки формы
- 18.7RT1Y 17.7 Сообщения об ошибках, которые можно понять
- 18.8RT1Y 17.8 Навигация — как не потерять человека по дороге
- 18.9RT1Y 17.9 Тексты интерфейса как часть требований
- 18.10RT1Y 17.10 Как описать экран так, чтобы агент не гадал
- 18.11RT1Y 17 Итоговый тест5 Questions
- 18. Управление ИИ-агентами14 Items
- 19.1RT1Y 18.1 Как агент видит ваш проект и его файлы
- 19.2RT1Y 18.2 Что такое контекст и почему он ограничен
- 19.3RT1Y 18.3 Файл AGENTS.md — правила проекта для агента
- 19.4RT1Y 18.4 Что класть в правила, а что не засоряет контекст
- 19.5RT1Y 18.5 Скиллы — повторяемые процедуры вместо длинных промптов
- 19.6RT1Y 18.6 Когда длинная сессия начинает портить результат
- 19.7RT1Y 18.7 Как понять, что контекст пора сбросить
- 19.8RT1Y 18.8 За что вы платите — токены, чтение и переписывание
- 19.9RT1Y 18.9 Выдуманные API и несуществующие пакеты
- 19.10RT1Y 18.10 ‘Всё готово’ при недоделанной работе
- 19.11RT1Y 18.11 Самовольный рефакторинг и цикл бесконечных правок
- 19.12RT1Y 18.12 Как распознать, что агент поехал
- 19.13RT1Y 18.13 Когда несколько агентов помогают, а когда мешают
- 19.14RT1Y 18 Итоговый тест5 Questions
- 19. Постановка задач агенту11 Items
- 20.1RT1Y 19.1 Как разложить спеку до задачи в один диф
- 20.2RT1Y 19.2 Признаки слишком крупной задачи для агента
- 20.3RT1Y 19.3 Признаки слишком мелкой задачи и лишней дробности
- 20.4RT1Y 19.4 Когда задача готова к передаче агенту
- 20.5RT1Y 19.5 Definition of Ready простыми словами
- 20.6RT1Y 19.6 Definition of Done — по чему принимать результат
- 20.7RT1Y 19.7 Что обязательно дать агенту вместе с задачей
- 20.8RT1Y 19.8 Зачем нужны примеры, ограничения и антипримеры
- 20.9RT1Y 19.9 Итерация и уточнение вместо переписывания с нуля
- 20.10RT1Y 19.10 Какие задачи агенту отдавать нельзя
- 20.11RT1Y 19 Итоговый тест5 Questions
- 20. Качество: как проверять то, что писал не ты13 Items
- 21.1RT1Y 20.1 Два вопроса качества — работает и удобно ли
- 21.2RT1Y 20.2 Почему регресс нельзя проверять только руками
- 21.3RT1Y 20.3 Что такое тест и как он выглядит глазами новичка
- 21.4RT1Y 20.4 Юнит-тесты для правил предметной области
- 21.5RT1Y 20.5 Интеграционные тесты для базы и внешних связей
- 21.6RT1Y 20.6 Дымовые тесты для главных сценариев
- 21.7RT1Y 20.7 Почему тесты должны расти из спеки
- 21.8RT1Y 20.8 Чем опасны тесты, написанные по готовому коду
- 21.9RT1Y 20.9 Тестовые данные и наполнение базы для проверки
- 21.10RT1Y 20.10 Как читать pull request, не умея писать код
- 21.11RT1Y 20.11 Красные флаги в дифе — лишнее и опасное
- 21.12RT1Y 20.12 Команды make test и make lint в вашей приёмке
- 21.13RT1Y 20 Итоговый тест5 Questions
- 21. Ручное тестирование: то, что не сделает за вас никто14 Items
- 22.1RT1Y 21.1 Почему приёмку результата всегда делает человек
- 22.2RT1Y 21.2 Что агент не видит в принципе
- 22.3RT1Y 21.3 Как проходить сценарий руками системно, а не хаотично
- 22.4RT1Y 21.4 Чек-лист из критериев приёмки
- 22.5RT1Y 21.5 Исследовательское тестирование — как ломать осознанно
- 22.6RT1Y 21.6 Где пользователь запнётся и бросит форму
- 22.7RT1Y 21.7 Тексты и ошибки глазами живого человека
- 22.8RT1Y 21.8 Почему нужен прогон на реальных данных
- 22.9RT1Y 21.9 Проверка на реальных людях, а не на идеальном кейсе
- 22.10RT1Y 21.10 Мобильный экран, медленный интернет и старый браузер
- 22.11RT1Y 21.11 Доступность — если человек видит или управляет иначе
- 22.12RT1Y 21.12 Как фиксировать находки для точечной правки
- 22.13RT1Y 21.13 Когда найденное — баг, а когда дыра в спеке
- 22.14RT1Y 21 Итоговый тест5 Questions
- 22. Выкладка: пайплайн, стенд и продакшен в России14 Items
- 23.1RT1Y 22.1 Что такое пайплайн и зачем он одиночному проекту
- 23.2RT1Y 22.2 Из каких шагов состоит нормальная выкладка
- 23.3RT1Y 22.3 Почему главная ветка должна оставаться зелёной
- 23.4RT1Y 22.4 Как передавать секреты без хранения в репозитории
- 23.5RT1Y 22.5 Как выбрать VPS и хостинг из России
- 23.6RT1Y 22.6 Первый вход на сервер и базовая подготовка
- 23.7RT1Y 22.7 Что такое домен и как он указывает на сервер
- 23.8RT1Y 22.8 DNS — почему адрес начинает работать не сразу
- 23.9RT1Y 22.9 Обратный прокси и зачем нужен замок в браузере
- 23.10RT1Y 22.10 Локально, стенд и прод — три разных окружения
- 23.11RT1Y 22.11 Выкладка первой версии и проверка после релиза
- 23.12RT1Y 22.12 Миграции на проде — самая опасная операция
- 23.13RT1Y 22.13 Бэкап и проверка восстановления, а не только копии
- 23.14RT1Y 22 Итоговый тест5 Questions
- 23. Безопасность и правовые границы13 Items
- 24.1RT1Y 23.1 Как секреты утекают через репозиторий и логи
- 24.2RT1Y 23.2 Почему нельзя класть секреты в промпты
- 24.3RT1Y 23.3 Prompt injection — когда данные управляют агентом
- 24.4RT1Y 23.4 Подменённые пакеты и атаки через зависимости
- 24.5RT1Y 23.5 Как понять, что приехало в ваш проект
- 24.6RT1Y 23.6 Аутентификация — как система узнаёт пользователя
- 24.7RT1Y 23.7 Авторизация по ролям — кто что может делать
- 24.8RT1Y 23.8 Проверка ввода и ограничение частоты запросов
- 24.9RT1Y 23.9 Персональные данные и что меняет 152-ФЗ
- 24.10RT1Y 23.10 Где хранить данные с учётом российского контекста
- 24.11RT1Y 23.11 Лицензии кода и заимствований — бизнес-риски
- 24.12RT1Y 23.12 Чек-лист аудита безопасности перед релизом
- 24.13RT1Y 23 Итоговый тест5 Questions
- 24. Инцидент: когда прод сломался12 Items
- 25.1RT1Y 24.1 Первые действия, когда прод перестал работать
- 25.2RT1Y 24.2 Почему нельзя чинить вслепую и сразу всё менять
- 25.3RT1Y 24.3 Где искать причину в логах и метриках
- 25.4RT1Y 24.4 Как отличить сбой кода от сбоя инфраструктуры
- 25.5RT1Y 24.5 Откат релиза — когда это самый быстрый путь
- 25.6RT1Y 24.6 Откат миграции — почему это отдельная история
- 25.7RT1Y 24.7 Хотфикс — когда можно срезать угол, а когда нельзя
- 25.8RT1Y 24.8 Что сообщать пользователям во время аварии
- 25.9RT1Y 24.9 Постмортем без поиска виноватых
- 25.10RT1Y 24.10 Что менять в правилах агента после инцидента
- 25.11RT1Y 24.11 Что менять в спеке и пайплайне после аварии
- 25.12RT1Y 24 Итоговый тест5 Questions
- 25. Итог: сдача проекта и перенос подхода10 Items
- 26.1RT1Y 25.1 Как сдавать проект по критериям приёмки
- 26.2RT1Y 25.2 Финальная проверка приложения перед показом
- 26.3RT1Y 25.3 Разбор pull request с посеянными дефектами
- 26.4RT1Y 25.4 Как замечать лишние и тихие правки
- 26.5RT1Y 25.5 Карта системы как итоговый документ проекта
- 26.6RT1Y 25.6 Журнал решений как защита от пересмотра хаотично
- 26.7RT1Y 25.7 Как входить с этим подходом в чужой проект
- 26.8RT1Y 25.8 Как перенести метод на свою рабочую задачу
- 26.9RT1Y 25.9 Что учить дальше после первого продакшена
- 26.10RT1Y 25 Итоговый тест5 Questions
This content is protected, please войти and записаться in the course to view this content!
RT1Y 4.4 Что делает брокер сообщений между частями системы
Предыдущий
RT1Y 4.6 Kafka — когда важен поток событий, а не очередь
Следующий