Посмотрел недавно видео : Игорь Рыбаков и Гор Нахапетян обсуждают коммуникацию. Больше всего меня зацепил рассказ Рыбакова. Оказывается, компания Технониколь была на грани распада. Казалось бы, что нужно? Большой бизнес, опытные руководители, устойчивая компания, много денег. Но основатели упорно идут в конфликт. Почему?

Причем здесь It?

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

Часто таким запросом страдают разработчики. Хочется показать, что ты "познал дзен", нашел серебряную пулю и т.п. Ты начинаешь убеждать , давить , уговаривать. Ты хочешь стать лидом, чтобы всех научить. Думаешь, что будет легче, потому что ты то знаешь. Становишься лидом, но становится только хуже. Возникает синдром самозванца, выгорание и т.п.

Или ты ищешь новое место, только потому что здесь одни дураки. Тебе кажется, что там будет лучше. Там люди умнее. Они меня поймут. Но нет - не поймут.

Запрос останется неудовлетворенным. Твой мозг ленивый. Он генерирует эти простые и понятные реакции, интуитивные шаблоны поведения. Но причина в самореализации, смысле и значимости - такие шаблоны здесь не работают. После смены работы, должности, статуса ты вернёшься в конфликт по той же причине, но с другими людьми и на другом уровне. Проблема внутренняя.

Я тоже был в такой ситуации, в может до сих пор в ней…. 

Что делать? 

1. Осознать наличие проблемы: если в конфликте ты испытываешь стресс, он оказывает деструктивное воздействие - проблема есть. Не нужно искать причину и виновных. Просто - есть проблема.

2. Принять 2 факта: 

1. людей нельзя изменить, они могут измениться сами если захотят.

2. единственное на что ты можешь влиять и менять - это ты сам.

Банально, но осознание этих пунктов меняет вектор приложения сил с внешнего на внутренний: НЕ ОНИ должны, А Я должен.

Что конкретно, я должен делать?

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

2. Иди туда, где можно проверить идеи, найти единомышленников, друзей по несчастью. Например Хабр, не нужно писать статьи, пиши  короткие и содержательные посты. 

Например, такой или такой. 

Мне помогло. Не факт, что поможет вам. Но если других вариантов нет - стоит попробовать.

Канал

Дели код на области (scope) - второй принцип. Полный список принципов здесь

Получил задачу, нужно подумать о области реализации. Иерархия областей такая: бизнес домен -> поддомен -> ... -> поддомен -> модуль(пакет) -> функция.

Чем глубже задача в иерархии декомпозиции, тем глубже область реализации в иерархии областей/слоев. Если ты разработчик, твоя зона: поддомен -> модуль(пакет) -> функция. Может быть так:

• эпик содержит общее описание, покрывает несколько поддоменов, про модули тут ничего не понятно

• история(сторя) в эпике описывает конкретный вариант использования, покрывает модуль поддомена. Если история покрывает больше одного модуля или поддомена, нужно подумать над декомпозицией.

• техническая задача из истории - слой вниутри модуля на фронте или модуль на бэке.

Сore domain и всякие другие domain - это лирика-теория для аналитиков. Для разработчика это лишний информационных шум.

Здесь нужно быть внимательным, потому что:

1. границы субъективны, зависят от понимания смысла, целей, отвественности компонента,

2. для бэка и фронта границы областей проходят по разному в рамках одной системы:

   • для бэка поддомен->модуль совпадает с сервис->модуль/пакет или микросервис. Сервисы типа BFF и GraphQL - исключения, их можно считать частью глобального слоя контроллеров;

   • для фронта в слое контроллеров UI компоненты имеют свои границы, отличные от границ поддомен->модуль, но в остальных слоях совпадают.

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

Допустим, я разработчик бэка. Задача: сделать фасетный и текстовый поиск товаров. Есть сторя с описанием контракта. Тогда моя зона: поддомен -> модуль(пакет) -> функция модуля. Мысли такие:

1. Поддомен уже понятен - обсудил в процессе декомпозиции эпика с аналитиком. Это будет Каталог. Сделаю его отдельным сервисом.

2. Модуль примерно понятен: мне нужно сделать фасетный поиск. Скорее всего кроме поиска Каталог-сервис будет выдавать категории, продукты по отдельности и еще что-то. Фасетный поиск - модуль.

3. Фасетный поиск должен возвращать значения для фасетов и результаты. Кажется, у модуля 2 функции. Может стоит сделать 2 модуля, или это будет 2 интерфейса внутри одного модуля? Решу, когда буду думать над логикой, там станет понятна связанность этих функций. Нужно будет обсудить с коллегами.

На фронте эта же задача выглядит по другому: это будет страница поиска, в ней фасетые фильтры, список товаров, страницы, сортировка. А еще где-то в шапке поле для ввода текста. Тут нет речи о Каталоге, потому что по смыслу это страница и какие-то элементы ввода. Это не страшно. Пусть структура UI компонент соответствует интуитивным ожиданиям фронт разработчиков. Важно, что бы ожидания были у всех одинаковые. Это в слое контроллеров.
В слое приложения лежит логика построения запроса по контракту. Вот здесь появляется Каталог, как поддомен, и модуль фасетного поиска. Позже тут будет модуль категорий и отдельного продукта. Слой контроллеров будет использовать их в разных UI компонентах.

Область и ограниченный контекст - разные вещи. Поэтому мы здесь его не обсуждаем.

Деление на слои и области выглядит как "решётка":

Весь код должен быть раскидан по ячейкам. Рано или поздно у вас появится общий для нескольких модулей код. Он хочет занять несколько ячеек по горизонтали. Скорее всего он выполняет общую служебную функцию внутри слоя. Здесь можно поступить по-разному: вынести в отдельный пакет, модуль с одним слоем, как договоритесь с коллегами.

Как физически организовать решетку и общие пакеты разберемся дальше.

Хочу зафиксировать принципы проектирования, которыми я пользуюсь ежедневно. В этом посте будет обновляемый список, расшифровка каждого принципа - отдельный пост. Это мой личный опыт. Я не претендую на универсальность.

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

Принципы сформированы на основе практического применения информации из книг:

• Эрик Эванс. Предметно-ориентированное проектирование. Структуризация сложных систем.

• Вон Вернон. Реализация методов предметно-ориентированного проектирования - DDD.

• https://www.infoq.com/minibooks/domain-driven-design-quickly/

• Влад Хононов. Изучаем DDD – предметно-ориентированное проектирование.

• Роберт Мартин. Чистая архитектура.

В оригиналах некоторые вещи трактуются объемно и широко.

Я про конкретику, практику и про код, поэтому сознательно упростил или выбросил часть информации. Она мешает и запутывает не только новичков, но и опытных разработчиков. Поэтому это не классический DDD или чистая архитектура. Скорее это смешение и личный опыт. Попытаюсь выдавать информацию без "воды".

Погнали:

1. Дели код на слои

2. Дели код на области (scope)

3. Формируй структуру папок согласно делению на модули и слои

Дели код на слои - первый принцип. Полный список принципов здесь

Я еще не знаю задачу, но уже знаю, что в коде будет 3 слоя: приложение, инфраструктура, контроллеры. Отдельно конфигурация.

Этого достаточно, ведь у меня даже нет задачи. Я начну думать о моделях, адаптерах, объекта‑значениях, когда приступлю обдумыванию бизнес логики и реализации.

Слой приложения «главный». Он устанавливает правила и требования к интерфейсам других слоев. Он никому ничего не должен. Он не знает, как устроены другие слои, и что внутри, потому что он главный. Слой приложения не может требовать от других слоев навыков работы с закрытыми данными. Он не может передать объект с приватными свойствами в другой слой и хотеть, чтобы эти свойства были обработаны.

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

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

— как модель, которые хранят состояние пока запрос обрабатывается;

— сервис без состояния

— функция с валидации целостности

Контроллеры — это все, что касается ввода и вывода.

Этот слой обязан знать, что нужно слою приложения, обязан это предоставить в нужном формате. Он не может ничего требовать от слоя приложения, обязан работать с тем, что отдал слой приложения.

На фронте в этот слой попадает всё, что касается взаимодействия с пользователем и обработки событий:

— шаблоны, стили, функции, которые готовят данные для отображения и обрабатывают ввод пользователя

— обработчики событий

— обработчики роутов, потому что роутинг — это интерфейс ввода данных.

— слушатели сокет соединений

На бэке это код, который принимает входящие запросы и отдает ответ, фоновые контроллеры:

— контроллеры gRPC, HTTP,

— слушатели очередей,

— конструкторы ответа, мапперы данных в нужный формат и т. п.

— описание протоколов.

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

Инфраструктура

— обязана работать с тем, что отдает слой приложения

— обязана вернуть данные в формате, который требует слой приложения.

Здесь лежат:

— клиенты к хранилищам, другим сервисам, кэшам, очередям и т. п.

— конструкторы запросов к БД, очередям или другим сервисам

— мапперы данных слоя приложения в нужный формат и обратно

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

Это может быть конфигурация di‑контейнера, место ручного создания компонен. Конфигурация может присутствовать как дополнительные нотации в UI компонентах. Фреймворки и языки имеют разные методы конфигурирования, поэтому конфигурация не является слоем или может быть не явной.

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

На фронте слой контроллеров может часто меняться, контракт с бэком более стабилен — инфраструктура главная.

На бэке формат хранения может измениться после MVP, а контракт описан и стабилен — слой контроллеров главный.

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

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

Дедлайн есть всегда. Если ты его не знаешь, тебе его не сказали или сказали, что его нет - он все равно есть. Он настигнет тебя в самый неподходящий момент. Он будет для тебя "сюрпризом".

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

Периодически уточняй дедлайн. Дедайн может измениться. Ты его не контролируешь. Это нормально.  Он может измениться в силу внешних обстоятельств. Твоя задача - держать руку на пульсе и уточнять изменения в дедлайне. Не жди, что тебе скажут первым о изменениях - не скажут.

А у меня нет дедлайна. Думаешь тебе повезло? Нет. Это повод задуматься. Скорее всего у источника задачи нет стратегии, целей, долгосрочных планов, ожидания не соответствуют действительности. Он не понимает, что хочет. Задача - это идея, без понимания практического применения. Скорее всего ты в "болоте". Если компания "живая", дедлайн тебя настигнет. А может быть тебя хотят "слить" и это ловушка? Я видел такое, так бывает.          

Такой диалог:

Менеджер:
насколько трудоёмко вернуть галерею на страницу товара? Сейчас мы принимаем только 1 картинку, а нужно несколько.

Разработчик:
Просто взять и вернуть нельзя. Галерея была лет 5 назад, я даже не помню как она выглядела. Если надо - будем делать, не надо - не будем. Трудоемкость тут не причём, как мне кажется.

Менеджер:
Ну бизнес измеряет все часами и днями....

Как думаете, в контексте этого диалога, имеет значение, как бизнес считает сроки? Или сроки здесь вообще не важны?

Моя позиция такая: если оценки сроков влияют на нужно/не нужно, то скорее всего не нужно.

Нужно/не нужно должно определятся целями. Нужно/не нужно сейчас - важностью. Нет целей - как понять важно это или нет?

Оценки сроков важны, спору нет, но они должны влиять на приоритет:

• Если важная и её делать долго, то нужно начинать сейчас. Приоритет самый высокий.

• Если важная, но делать быстро и дедлайн далеко, доделываем текущие и начинаем важную. Приоритет высокий, но ниже текущих.

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

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

А бывает еще так, что менеджер или руководитель начинает давить, что бы уменьшить сроки... сами подумайте - оно вам надо?

P.S.: тут тоже пишу https://t.me/it_weekdays о буднях.

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

Вот продукт готов, покупатели и менеджеры довольны... Они твои пользователи.

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

Да, да.... это я, твой коллега, твой первый пользователь, твой продукт - это код, я им пользуюсь.

Почему ты не подумал обо мне: не написал README, не оставил инструкций, не озвучил подводные камни? Почему мне нужно провести реверс-инжинириг, просто что бы запустить или задеплоить проект?

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

Почему ты злишься, когда я комментирую код на ревью? Почему ты отвечаешь - "мне так удобно"? Почему... почему... почему?

После этого, ты удивляешься тому, что я не хочу иметь ничего общего с твоим продуктом и с тобой. Почему?