Fundamentals of Software Architecture: An Engineering Approach — Neal Ford, Mark Richards

https://www.audible.com/pd/Fundamentals-of-Software-Architecture-Audiobook/B08X917VLR

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

Первой полезной главной внезапно оказалась глава о модульности. Казалось бы, ну что ещё можно сказать о модулях, связности и т.п. думал я — но оказалось, что учиться и узнавать новое никогда не поздно 🙂 После рассказа про то, что такое модульность, авторы переходят в характеристикам определяющим степень связности внутри ПО. Начинают с coupling (тут было все знакомо), но затем переходят к непроизносимым (и с неугадываемым на слух написанием) cohesion и сonnascence.

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

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

Дальше авторы переходят к рассуждениям о том какие бывают архитектурные характеристики и о fitness functions для них. Материал сильно совпадает с книгой Building evolutionary architectures. Из нового (или упущенного мной при чтении той книги) — мысль о роли фитнес функций как инструмента управления (governance), когда архитектор непосредственно не пишет и не ревьюит код, но обеспечивает нужные характеристики через фитнес функции.

От самих характеристик разговор переходит на то, являются ли они характеристиками всей системы? Вводится понятие архитектурного квантума — части системы, которая обладает отличными от других частей НФТ. Тут мне показалось в книге присутствовал перекос в сторону — подумайте каким частями системы какие НФТ нужны и таким образом разбейте ее на разные квантумы, вместо — подумайте? правда ли разным частям вашей системы нужны разные НФТ, что потребует разбить ее на разные квантумы. Правильная мысль тут — если несколько выделенных вами квантумов используют одинаковый набор технологий и возможно даже общую бд — то точно ли итоговые НФТ у них получаются разные? Точно ли ваш код влияет на них настолько — если у вас супер scalable приложение, но при этом общая бд, без шардирования и возможностей кластеризации — уверены ли вы, что ваша система в целом scalable.

Следующей очень интересной главой была глава про компоненты, проектирование системы исходя из них. Не сказать, что что-то новое, но наводящее порядок в голове. Авторы пишут, что есть два основных подхода к выделению компонентов. Первый — исходя из технических характеристик (слоеная архитектура, mvc) — компонент работы с базой, компоненты бизнес логики, компоненты представления. Второй — исходя из бизнес-доменов, по заветам DDD. Оба имеют свои плюсы и минусы и какой выберете вы во многом должно зависеть от закона Конвея — как организованы люди у вас в компании. Если у вас отдельные отделы дба, бэкенда и фронтенда — вам ближе первый способ. Если же кроссфункциональные команды, отвечающие за отдельные части продукта — второй. Но верно и обратное, можно воспользоваться обратным законом Конвея и, если вы по каким-то причинам предпочитаете какой-то из этих подходов — надо переорганизовать команды, чтобы они соответствовали выбранной архитектуре.

Во второй части книги начинается описание архитектурных стилей. И начинается он просто огненно — упомянув, что базовым водоразделом между разными стилями является какая архитектура — монолитная или распределённая используется — авторы рассказывают о заблуждениях (fallacies), которые часто бывают при построении распределенных систем. Я просто перечислю их тут, а в книге к каждому заблуждению приводятся примеры и объяснения:

  • сеть надёжна
  • латенси равна 0 и ей можно пренебречь
  • сетевой канал бесконечно широк
  • сеть безопасна
  • топология сети и распределенных сервисов неизменна
  • существует только один администратор
  • транспортные расходы пренебрежимо малы

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

На этой оптимистичной ноте происходит переход к рассказу о разных архитектурах и для начала — о слоеной архитектуре. Ничего особо нового тут не говорится, разве что отмечу мысль об опасности скатиться к sink hole — когда промежуточные уровни в подобной архитектуре не делают ничего, а просто передают запросы дальше. Также интересная мысль, что с такой архитектуры часто начинают, так как она требует минимального продумывания на первом этапе и упрощает ориентирование в кодовой базе, пока она небольшая (как в зеркало гляжусь при чтении этого)

Далее авторы рассматривают

Рipeline architecture — интересный подход, тоже монолитный, но несколько снижающий сложность и повышающий независимость отдельных компонентов (если только вы не наворотите сложную сеть этих фильтров)

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

Service based architecture — первая распределённая архитектура. Авторы предлагают ее называть далее макросервисной — сервисы большие, продукт состоит из 6-20 сервисов. Чаще всего при этом используется одна БД. При использовании одной БД важное тут, чтобы сервисы не были связаны друг с другом структурой БД.

Event driven architecture — архитектура на основе обработки потока событий. Описывается два варианта топологии — broker и mediator. В первом случае есть только общая инфраструктура для передачи сообщений, логика определяется самими обработчиками событий, можно легко добавить новые обработчики, не предусмотренные ранее. Но очень сложно обрабатывать ошибки, очень сложно понять завершилась ли операция и успешно ли. Второй — с центральным медиатором, который управляет процессом и контролирует ошибки, завершение процесса и т.п.
Также в этой главе описываются вопросы асинхронной обработки сообщений без потери данных, организации запроса-ответа в эту архитектуре, но подробнее эта тема рассматривается в недавно прочитанной Enterprise Integration Patterns. У нас события активно используются и в этой главе ничего особо нового для меня не было.

Space based architecture — очень интересная архитектура, в которой центральная БД заменяется распределенным реплицированным кешем, таким как hazelcast или apache ignite. Или если данных много или они очень часто обновляются — общим распределенным кешем. Плюс — высокая скорость работы, высокая доступность (в случае реплицированного кеша). Минус — высокая сложность, ограниченная применимость (далеко не все данные можно полностью поместить в оперативную память, ещё и дублируя ее на многих нодах). Но интересно.

Затем авторы проходятся по orchestration driven service based architecture — как примеру того, что осталось в прошлом, хотя было нацелено на казалось бы благородную цель — максимальный reuse кода и компонентов. В итоге это на практике выливалось в очень сильную связность и сложность внесения изменений, так как от одних компонентов зависит множество других.

И наконец приходят, как к ее противоположности, к микросервисной архитектуре. Честно говоря в главе про нее ничего особо нового не говорится — мысли те же, про связанность ее с идеями DDD и bounded contexts. Важный момент про необходимость избегать распределенных транзакций и что их наличие в большинстве случаев говорит о том, что сервисы выделены неверно — или слишком мелко или не по тем границам — всё требующее транзакции, за очень редкими исключениями, должно быть внутри одного сервиса.

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

Последняя часть книги посвящена не архитектуре самой по себе, но работе архитектора:

  • как документировать и описывать архитектуру — тут описывается идея ADR. Мне показалось что оно должно быть хорошо применимо для больших команд, хотя возможно что какие-то важные моменты было бы неплохо так документировать и у нас (где только время на это взять)
  • анализ рисков, предлагается оценивать риски по метрике, характеризующей расположение риска на шкалах критичности и вероятности. Важная мысль — любая новая, неизвестная технология — это всегда high risk
  • насколько архитектор должен быть включен в работу команд, как найти правильный баланс на шкале control freak — armchair architect
  • базовые техники переговоров — основная мысль тут, что архитектурные решения надо не спускать сверху, а продавать разработчикам, объясняя зачем они приняты и по возможности давая разработчикам достаточно информации, чтобы они сами пришли к тому решению, которое считает правильным архитектор

Technology Strategy Patterns — Eben Hewitt

Книга о том, как техническому руководителю говорить с бизнесом, так чтобы бизнес его понимал, а он понимал бизнес. Или 100500 вариантов квадрантов на все случаи жизни 🙂

В первой части автор рассматривает паттерны для анализа, на которые по его словам опираются все остальные. MECE lists, logic tree, hypothesis. Собственно интересное из этого только первое, да и то больше из-за названия, которое раньше не слышал — речь про списки непересекающихся сущностей, покрывающих при этом всё пространство возможных вариантов. В остальном в этой части много хороших рассуждений, но уж совсем базовых. В частности советы о договориться о терминах, но после Эванса оно воспринимается как — ну а как иначе-то.

Далее автор описывает паттерны анализа контекста окружающего мира, влияющего на вашу стратегию. Начинает с PESTEL — опять незнакомое мне ранее слово — суть, что надо посмотреть на влияющие на вас текущие изменения в области политики, экономики, общества (society), технологий, окружающей среды (environment) и законодательства (legal)

И далее, опираясь уже на них, делать сначала scenario planning — набрасывая вероятные сценарии, затем futures funnel, классифицируя различные вероятные сценарии будущего, выделяя среди них с одной стороны более вероятные, а с другой более желательные нам. Ну и далее применять backcasting, рассуждая какие предыдущие шаги необходимы чтобы попасть именно в желаемое нами будущее.

Следующими идут паттерны для анализа industry context

SWOT pattern

Porter’s Five Forces

Ansoff Growth Matrix

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

Глава про Corporate context показалась не сильно интересной, потому что относится именно к работе в большой корпорации — все эти выясните стейкхолдеров, выясните откуда деньги, спланируйте запросы бюджета на проект весной, чтобы к следующему году этот бюджет получить… Ну и опять квадранты и квадранты.

Principles, practices, tools — идея из следующей главы про department context. Суть в том, что чтобы быть уверенным что компания движется в правильном направлении, мы обозначаем набор принципов, которым мы следуем как компания, но не останавливаемся на этом — а для каждого принципа перечисляем набор используемых практик и инструментов, поддерживающих эту практику. Предполагается выражать это например с помощью диаграмм https://sankeymatic.com/
Идея очень перекликается с идеями из курса системного мышления Левенчука, что мы меняем состояние альф, используя практики, поддержанные технологией. И принципы в таком случае должны отражать характеристики тех изменений в реальном мире, которые мы хотим получить в ходе деятельности нашей команды.

Другая идея из этой главы — application portfolio management (APM) — идея, что все разрабатываемые приложения оцениваются с одной стороны по степени их полезности для бизнеса, а с другой — по стоимости их поддержки — на основе этого принимаются решения от каких стоит отказаться, на какие направить лучшие силы и т.п. Опять предлагается рисовать квадранты 🙂

Вторая часть книги посвящена коммуникациям — когда вы решили, что и как делать — как донести эту мысль до всех от кого зависит ее реализация.
Начинает автор с базовых идей — формулировать ответы в виде кратких 30 секундных ответов, смотреть на ситуацию непредвзято как это делал бы внешний консультант. Затем проходится по основным типам логических ошибок и наконец рассуждает как правильно добиваться принятия своих идей. Организационно — составить список стейкхолдеров на которых они повлияют и постараться в личных встречах и переписках сначала заручиться поддержкой их насколько это возможно (или как минимум узнать их опасения). Затем — кратко рассказывает основы сторителлинга.

Потом автор рассказывает, как организовать Scalable business machine — но выходит весьма краткое и неполное перечисление элементов системной схемы проекта из курса системного мышления Левенчука (которая в свою очередь основана на OMG Essence). Прямо вот это всё — что делаем в физическом мире, кто делает, какие роли есть в проекте, для кого делаем, с помощью каких практик, при помощи каких технологий — другими словами и по верхам, но о том же.

И в завершение показывает шаблоны которые использовать для презентации своих идей. Такие как One-slider — выражаем наше видение и как мы планируем реализовать его на практике кратко в одном слайде подобной структуры

А также Use Case Map, Priority Map, Technology Radar, Ghost desk, Ask desk и другие

Мне пока эта часть показалась не сильно полезной, наверно потому что работаю не в корпорации, где все это бы пригодилось 🙂

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

The Phoenix Project

Книга достаточно часто упоминалась в позитивном ключе в разных подкастах и твиттере — как книга-вдохновение для внедрения девопс.

Что могу сказать — авторы явно очень вдохновлялись Целью Голдратта 🙂 Настолько, что даже явно упоминают ее неоднократно в книге. Так что если вы читали Цель — то это она, но про нашу индустрию.

Как и Цель — это производственный роман, описывающий идею — так что главное тут не персонажи, они весьма шаблонные, а идеи трансформации в работе IT.
Книга состоит из трёх частей — в первой описывается как было, во второй как из этого выбрались, ну и в третьей — движение к новым вершинам ) И честно говоря самой увлекательной была первая. Все эти проблемы, происходящие одновременно и необходимость и выбираться из них и как-то менять работу к лучшему… Честно говоря, такое начало породило у меня завышенные ожидания — я думал, что авторы покажут, как в таком режиме герои смогут осуществить трансформацию процессов работы, ещё и без поддержки начальства. Но увы — в конце первой главы главный герой кладёт заявление на стол и дальше появляется deus ex machina — влиятельный наставник и член совета директоров внезапно влияет на СЕО, да так, что тот внезапно прозревает (с чего бы?), заявляет, что был не прав и даёт главному герою полный карт-бланш на изменения, одновременно ещё и устраивая какой-то сеанс психотерапии с рассказом о своих слабостях и проблемах (что это вообще было?..). Увы-увы. На этом какая-то интрига и накал спадают (лишь изредка делается попытка создать хоть видимость интриги с нависающими сроками и интригами от главы маркетинга, метящей в СЕО — но слабенькая). И дальше книга превращается сначала в иллюстрацию того, как понять что ИТ должно делать для бизнеса. Тут все прямо как в Technology strategy patterns, которую я как раз читаю параллельно — составить список стейкхолдеров, составить список их KPI, составить список какие действия или бездействия IT больше всего влияют на них, определить какие меры могут дать максимальное влияние на показатели составляющие KPI руководства — привязать и показать прямую связь действий ИТ команды с конкретными бизнес показателями.
А затем следует иллюстрированный примерами перечень идей по девопс трансформации — тут на сегодняшний день тоже никаких откровений — автоматизация деплоя и тестирования, уменьшение батч сайза релизов, частые и автоматические релизы, определение и устранение узких мест, плотная работа с бизнес-заказчиками. С учётом того, что внедряется оно в книге в режиме «придумали — без проблем внедрили, получили огромный профит» — не увлекает, внедрение контроля над изменениями в первой части было увлекательнее 🙂

Но в целом потраченного времени на прочтение (а точнее прослушивание) не пожалел 🙂 Первая часть была вообще огонь 🔥 — начало второй разочаровало, а дальше в принципе как неплохая бизнес-книга.

Building Evolutionary Architectures

https://learning.oreilly.com/library/view/building-evolutionary-architectures/9781491986356/

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

В первых главах автор (их несколько, но думаю кто-то из них 🙂 ) рассуждает о том, что в современном мире программные системы не статичны — возможность развития и изменения в соответствии с меняющимися условиям бизнеса является важным требованием сама по себе. При этом любая архитектура программной системы должна удовлетворять своему списку -bilitys (например scalability / high availability / security / … ). Пусть мы определили, какие требования к архитектуре нашей системы и наш программный продукт удовлетворяет им в текущий момент, но если мы говорим о поддержке изменений и развития необходимо отслеживать, что все эти -bilitys продолжают соблюдаться. Для этой цели вводятся fitness functions — измеримые показатели соответствия каждому из -bilitys. Это могут быть время отклика веб страницы, время доставки товара, количество инцидентов, степень покрытия тестами и т.п. Мы встраиваем измерение этих характеристик или просто в наш мониторинг или если речь про характеристики кода — прямо в пайплайн, не позволяя им снижаться.

Далее он рассуждает о разных архитектурах и насколько легко они поддаются эволюции. Несколько легко для них отслеживать связи и зависимости, определять фитнес функции, писать функциональные тесты. Начинает с big ball of mud и через монолит, систему с интеграционной шиной, сервисную архитектуру доходит до микросервисной. В процессе часто упоминается DDD и присущие ему идеи, такие как bounded contexts.

Бегло пройдясь по эволюции данных (очень бегло, скорее просто упомянув что эволюция данных требует особого внимания и приведя пару примеров) автор переходит к рассуждениям о том, что усложняет эволюцию программных систем и какие частые ошибки и антипаттерны бывают тут. Основная мысль тут в принципе одна и повторяется в разных примерах — больше всего мешает эволюции софта сильная связанность и неявные зависимости.

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

В последних главах автор рассуждает о том как внедрять эволюционные подходы к построению архитектуры в существующие проекты, а также надо ли это делать. И это очень важные мысли — во-первых, все эти подходы не бесплатны и требуют дополнительных затрат времени и мыслетоплива. Нет смысла применять их, если мы делаем проект, время жизни которого изначально строго ограничено. Во вторых, они имеют смысл начиная с определенного размера проекта (как по объему кода, так и по количеству людей в команде) и должны включать в себя не только технические, но и что важнее определенные организационные подходы. Слабая связанность, микросервисы и т.п. упрощают развитие ПО, только если за эти разные слабо связанные сервисы отвечают разные команды

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

Eric Evans — Domain-Driven Design: Tackling Complexity in the Heart of Software

После короткой книги Vladik Khononov я решил, что надо углубиться в тему DDD и прочитать книгу Eric Evans, раскрывающую тему более подробно. Совсем не пожалел и в очередной раз убедился, что некое краткое изложение — это хорошо, но более подробная и полная книга позволяет действительно проникнуться идеями.

Книга состоит из 4х больших частей.

В первой автор рассуждает о важности общей модели предметной области — общей и для программистов и для представителей бизнеса. Сама мысль изложена и в What is domain driven design, но тут она подается подробнее, с примерами из жизни. Интересная мысль, что целостность модели и ее общий язык — это не только то о чем мы договорились в начале. Если в процессе работы мы нашли более удачные слова, точнее описывающие нашу область и лучше понятные бизнесу, то необходимо отразить это в том числе в коде. Необходим рефакторинг кода, для того чтобы используемый в нем язык продолжал совпадать с языком модели, чтобы не происходило постепенного расхождения.

Во второй — автор переходит от общих рассуждений о моделецентричности при разработке к конкретным предложениями как проектировать ПО так, чтобы в итоге оно отражало модель предметной области. Для этого сначала вводятся понятия entity, value object, service описывающие различные составные части системы. Затем — aggregate, группирующий их в тесно связанные с точки зрения бизнеса блоки, factory — для создания сущностей и агрегатов, repository — для внешнего хранения сущностей и восстановления их из внешнего хранилища в память. В конце главы приводится пример проектирования системы управления перевозкой товаров на основе предлагаемых принципов из этих кирпичиков.
С одной стороны здесь не описывается ничего революционного, но с другой методично и с примерами показывается как может быть упрощена или наоборот усложнена система, если глубже вникнуть в бизнес требования и отразить их при проектировании. Как влияет на дизайн правильное понимание, что в бизнес области является entity, а что просто value, т.е. определяется только своими свойствами и не требует отслеживания уникальности. Как упрощает систему замена двунаправленных связей однонаправленным, где это возможно. Как грамотное использование репозиториев может решать проблемы с конкретными изменениями (опять таки если бизнес требования позволяют это)

В третьей части автор обсуждает рефакторинг, как необходимый компонент поддержания соответствия кода модели, по мере ее изменения и усовершенствования. Начинает он с примера из жизни, когда вникнув глубже в доменную область, удалось создать более удачную её модель, что с одной стороны позволило упростить дальнейшую разработку, устранив недопонимания с бизнес-заказчиками, но с другой потребовало существенного переписывания системы под новую модель. После этого, ещё порассуждав о том, что модель постоянно улучшается и меняется — переходит к рассуждениям о гибком и в то же время понятном дизайне приложений. Сначала обсуждается, как лучше отражать бизнес-правила и ограничения в коде. Альтернативой вынесения сложной бизнес логики в уровень приложения предлагается создание классов-спецификаций, инкапсулирующих внутри себя проверку неких бизнес-правил, а возможно во взаимодействии с репозиториями и выборку объектов, удовлетворяющих спецификации.
Другими инструментами гибкого дизайна автор называет:
— интерфейсы, с понятными названиям как самих классов, так и методов, чтобы из самих их названий было понятно, что они делаютчистые функции
— операции над иммутабельными объектами
— операции над value objects, которые бы возвращали новые value objects

В четвертой части автор переходит к вопросам организации работы большой компании со сложным продуктом, над которым работает несколько команд. На примерах он показывает, какие проблемы могут возникнуть, когда команды работают в рамках своих моделей, но их границы четко не очерчены и одна команда может вносить изменения, нарушающие работу кода, поддерживаемого другой. Чтобы не допускать таких проблем предполагается концепция bounded contexts — четко очерченных границ моделей, с понятными местами их пересечения. Если это сделано — то, как минимум проблема обозначена и обозначены пересечения, по которым работа должна быть в какой-то степени совместной и надо принять решение как будет построена эта работа.
Автор рассматривает следующие способы взаимодействия команд, по степени уменьшения степени интеграции: continuous integration, shared kernel, upstream/downstream, anticorruption level, open host service, separate ways. Суть ясна из названий, разве что стоит пояснить что под anticorruption автор понимает набор фасадов/адаптеров, которые защищают нашу модель от «повреждения» неподходящей нам чужой моделью. Важная мысль при этом, что выбор модели взаимодействия — это чаще всего не техническое, а организационное решение и зависит прежде всего от размера команд, их взаимоотношений, их организационной подчинённости, общности их целей.

Но возвращаясь чуть назад, как разделить единую и ставшую слишком сложной и запутанной модель на отдельные bounded contexts, чтобы с одной стороны над ними могли работать независимые команды, а с другой — чтобы усилия наиболее сильных программистов (команд) были направлены на действительно важные вещи, а какие-то менее критичные могли бы быть сделаны силами джунов или вовсе отданы на аутсорс?
Для этого необходимо провести model distillation — анализ модели и выделение, что в ней является нашим core domain — тем, что мы на самом деле делаем, что составляет цель нашего продукта, чем он отличается от конкурентов. А что является generic / supporting domains — частями продукта, которые необходимы, но при этом могут быть такими же как у всех вокруг, решают задачи поддержки, не являются основными. Часто такими частями являются биллинг, поддержка, общие технические модели работы с сетью / датами и т.п.
Для упрощения основной модели полезно выделить generic subdomains в отдельные модули / команды, а возможно и отдать на аутсорс для ускорения разработки. Другим подходом может быть наоборот явное выделение в отдельный модуль / сервис в первую очередь core domain (автор называет этот подход segregated core), а уже потом распиливание остатка.

В конце книги автора рассуждает о том, как поддерживать целостный дизайн больших сложных систем. Одним из решений для этого он видит слоеную архитектуру, которая бы с одной стороны ограничивала дизайн-решения, не позволяя создать беспорядочный клубок связей, с другой стороны делала бы систему более понятной (в том числе за счёт дополнительной информации о принадлежности модулей разным слоям). Но при этом автор предупреждает об опасностях излишнего увлечения глобальными структурами / генеральными планами — когда они не дают достаточной гибкости программистам, они становятся не помощниками, а наоборот — силы начинают тратиться на поиски обходных путей и впихивание невпихуемого. Также плоха идея выделения специальной команды лучших программистов чисто для создания общей архитектуры — если они не участвуют в решении повседневных задач, то вероятность создания переусложненной и только мешающей работе системы повышается. И вообще

Team divisions that assume some developers are not smart enough to design are likely to fail because they underestimate the difficulty of application development. If those people are not smart enough to design, they shouldn’t be assigned to develop software. If they are smart enough, then the attempts to coddle them will only put up barriers between them and the tools they need

Vladik Khononov — What Is Domain-Driven Design?

Очень небольшая книга, кратко описывающая основы DDD. Несмотря на свой размер содержит очень большое количество информации и минимальное количество воды.

  • Очень кратко описывается понятие домена (core / generic / supporting), субдоменов, ubiquitous language, bounded contexts.
  • Рассматриваются различные способы взаимодействия между командами, работающими в bounded contexts (как оно общепринято переводится на русский искать пока было лень).
  • По верхам пробегается по паттернам организации кода — transaction script, active record, domain model, event sourcing domain model.
  • Также по верхам по архитектурным паттернам — слоеная архитектура, порты и адаптеры, CQRS.
  • Дальше автор перескакивает от кода опять к организационным практикам — обсуждает event storming и эволюцию доменов (переход между core / generic / supporting при изменениях ситуации на рынке)

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

Gregor Hohpe, Bobby Woolf — Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions

Книга посвящена паттернам построения приложений на базе систем передачи сообщений. Выпущена в 2003 году и это чувствуется (кругом XML и SOAP, древние версии .net и java) — но при этом основные идеи не устарели и замечательно перекладываются в голове на Redis, Kafka и т.п.

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

Во второй авторы рассматривают 4 основных способа интеграции приложений — передача файлов, общая БД, RPC и передача сообщений (messaging). Описываются их плюсы и минусы, причем не только технические, но и организационные (особенно касаясь общей БД). Наиболее гибкой, но при этом и более сложной авторы видят интеграцию посредством передачи сообщений.

В следующих главах последовательно рассматриваются:

  • Основы построения систем, используя передачу сообщений. Ничего особенного, но полезно посмотреть и на свою систему, используя предлагаемые функциональные элементы.
  • Каналы передачи сообщений — на какие типы можно поделить, и какие когда и как использовать. Важная мысль про спец. каналы для ошибочных сообщений, причем ошибочных именно с точки зрения транспорта и потому явного отделения уровня транспорта от логики приложения
  • Сами сообщения. Рассуждения, что сообщения бывают трёх типов — команды, данные и события и какие есть особенности у разных типов ( такие как, например, канал, куда помещать ответ у команд и время жизни у событий )
  • Message router. Автор рассматривает сначала относительно простые темы, как content based router и альтернативы ему в виде фильтров сообщений, а затем переходит к более сложным (и интересным) темам — как splitter / aggregator сообщений, resequencer (по русски видимо восстановитель очередности — звучит так себе :). Особенно понравилось, что темы не просто поверхностно обозначены, но также обсуждаются сложности при реализации ( например, какие есть варианты аггрегатору понимать, что сообщения закончились? какого размера должен быть буфер у resequencer и как избежать его переполнения?) и трейдофы различных решений.
  • В этой главе интересная мысль, что проблема нарушения очередности сообщений в системе построенной на их обмене — это та же проблема, которая решается в tcp — который по своей сути протокол обмена сообщениями по нестабильной сети, в котором порядок сообщений важен. И потому полезно представлять, как tcp работает и какие решения применяет, и с какими трейдофами (окно сообщений и способы определения его размера / подтверждение получения сообщений и т.п.)
  • Далее рассматриваются ещё более сложные паттерны, реализующие многоэтапный бизнес-процесс — route slip, process manager и message broker. Самое ценное при этом — опять таки обсуждение применимости.
  • Трансформация сообщений. Больше общие рассуждения о том как лучше организовать связь между собой приложений с разными форматами сообщений. Рассматривает такие паттерны как envelope message, content enricher, content filter, claim check и normalizer. Суть большинства ясна из названия, claim check — удаление из сообщения части информации, но с тем, чтобы вернуть ее в него позже, на последующих этапах обработки бизнес-транзакции.
  • Вопросы взаимодействия приложения с системой передачи сообщений. Отделение кода работающего с ней от основного кода приложения, poll / push модели чтения сообщений, способы организации отработки одной очереди несколькими экземплярами приложения или несколькими приложениями.
  • Особенности эксплуатации системы на базе передачи сообщений. Рассматриваются паттерны, описывающие как организовать конфигурирование системы и переконфигурирование ее в реальном времени, логирование запросов, сбор метрик.

Главы сопровождаются примерами на java используя JMS и на .Net, а также бизнес-ситуациями, при которых могут использоваться одни или другие описанные паттерны. Примеры кода часто выглядят сильно учебными и слегка устаревшими (особенно когда там XML и рассуждения про SOAP и чего нет в .Net 1.1), но все равно полезны ещё и для понимания терминологии и того как одни и те же вещи по разному могут называться в разных имплементациях. Особенно полезны несколько глав с примерами ближе к концу книги, где одну и ту же задачу сначала решают разными путями, а потом наворачивают получившееся решения для использования в продакшене — добавляют мониторинг, фейловер одной из систем и т.п.

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

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

Brendan Burns — Designing distributed systems

Книга представляет собой обзор паттернов разработки распределенных приложений используя контейнеризацию.

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

Sidecar — второй контейнер рядом с основным, расширяющий его функциональность. Как теория ок. Примеры автор приводит сначала про добавление поддержки https к легаси системе — наверно имеет право на жизнь, если легаси настолько старое, что и правда засунуть его в контейнер будет проще. Следующий пример понравился уже сильно меньше — контейнер который добавляет мониторинг соседнего и некую веб морду с данными о использовании ресурсов. Имхо для таких целей нужен все таки какой-то централизованный мониторинг причем с графиками по времени и т.п. типа как даёт заббикс. Поэтому пример выглядит нежизненным. Третий пример про реализацию доставки изменений через гит репозиторий посредством контейнера который в цикле делает пулл из него. Ну такое. Имхо правильным будет всё-таки когда доставку изменений производит сторонняя система по событию пуша в гит репозиторий, а не трата ресурсов на пулл в цикле.

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

Ambassador — через второй контейнер происходит взаимодействие с внешним миром. От первого примера про шардинг у меня знатно подгорело. Пример собственно про то, что сделаем шардинг редиса так, чтобы для приложения он был как будто один и нам его менять не пришлось. Поднимают 3 независимых редиса, и контейнер-прокси запросы к себе распределяет на них. Ааааа! Кластер редиса делает это сам по себе из коробки, давая при этом ещё и отказоустойчивость. А если заменить редис на какую-то не key-value базу — то там так просто на прокси запросы от приложения не поделишь, совсем приложение не трогая. Другие примеры — сервис-брокер для сервис-дискавери и канареечный релиз / дублирование продакшн трафика на тестовое окружение. Первый да, могу понять, если сервис-дискавери делается не посредством днс. Со вторым так и не смог для себя придумать, когда это было бы полезно делать со стороны клиента, а не сервера принимающего запросы — тестировать то мы будем изменение поведения сервера.

Адаптер. Похоже на амбассадора по сути, но смысл использования — предоставление интерфейса, который основной контейнер не предоставляет. Тут у меня наконец-то вопросов не возникло. И кейсы с мониторингом редиса и изменением формата логов понятные.

Дальше в книге начинаются паттерны для распределенных систем и там уже все выглядит вполне понятно, но в то же время и весьма лайтово (сильно лайтовее книги с кабанчиком). Рассматриваются шардирование, реплики стейтлесс сервисов, scatter/gather паттерн (отправка запросов сразу на несколько серверов и объединение ответа от них в ответ пользователю). Примеры по прежнему не впечатляют, но уже скорее из-за своей простоты. Например пример где делают консистент хешинг на nginx, но при этом на фиксированном в конфиге числе апстримов, учитывая что до этого шла речь про изменение числа шардов, ожидал бы тут какой-то пример, где это самое число шардов можно было бы менять на лету.

Следующая глава посвящена FAAS — function as a service. Общие рассуждения о применимости, удобстве и экономической обоснованности при разной нагрузке полезны. А вот первый предлагаемый пример использования странный — предлагается декоратор по такой схеме: пользователь -> декоратор -> основное приложение. Если декоратор условная лямбда на Амазоне, то если ответ идёт по тому же пути, то декоратор висит все время запроса и мы платим за все это время. Чтобы эта схема была экономически не провальна, мне кажется, нужно усложнять получение ответа от основного приложения в таком сценарии, что никак не согласуется со сценарием — просто добавим декоратор на FAAS, чтобы не править основное приложение.

Выбор мастера и владение (ownership) ресурсом. Первая глава в книге, к которой у меня нет претензий. Более того — она дала мне очень важный инсайт, т.к. на самом деле речь в ней идёт о распределенном локе. Распределенные локи активно используются у нас в коде ( реализованы через редис ). И почему-то раньше я не задумывался о том, чтобы использовать их же для того, чтобы только один наш демон читал определенную очередь (по пулл модели), а думал как-то дополнительно прикручивать zookeper и какой-то более сложный механизм выбора мастера. Глава дала хорошую пищу для размышлений. Также полезной была мысль, что хотя современный оркестратор способен обеспечивать некоторые гарантии fault tolerance, перезапуская упавший контейнер и перенося его с упавшей машины — этого недостаточно при частом деплое.

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

Общее ощущение от книги — она простовата и наверно скорее полезна как обзорная для новичков. Примеры скорее учебные и не очень близки к реальным. Но в целом прочитать было полезно.

Martin Kleppmann — Designing Data-Intensive Applications

Долгие годы источником новых знаний в IT для меня был хабрахабр, но или я его перерос или он в последние годы скатился, но что-то стоящее там попадается всё реже и реже. Настолько, что становится жалко времени, которое тратится на перелопачивание новых статей и невольное залипание во всяких статьях, обсуждающих текущие новости, ценность которых, если смотреть даже с небольшого отдаления, стремится к нулю. Достойной замены я ему пока не нашёл, некоторое количество людей в твиттере и медиуме — это всё ещё не то, да и соотношение польза/шум в твиттере не сильно лучше хабра, даже если стараться подписаться на кого-то, от кого прилетает время от времени интересный материал.

В итоге пока решил переключиться на книги, тем более, что книг по специальности я прочёл не так много — в основном потому, что читаю я в основном с читалки или телефона, и специальную литературу в pdf и там и там читать неудобно.

Но технологии не стоят на месте 🙂 Оказалось, что весьма удобную оболочку для чтения книг даёт в своём приложении O’Reilly. К тому же в полном соответствии с мотивационными теориями, если ты за что-то заплатил, то твоя мотивация это использовать заметно повышается 🙂

Это была присказка, а первой прочтённой мной на платформе O’Reilly книгой стала классическая книга с кабанчиком, о которой дальше и пойдёт речь.

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

Дальше крупными мазками по содержанию.

Книга состоит из трёх частей. Первая — представляет собой обзор способов хранения и обработки данных в пределах одной машины:

  • Какие бывают БД, как они развивались и для каких задач лучше подходят. Тут очень интересным было читать про графовые БД, так как я сам плотно с ними не работал. Особенно порадовало сходство Datalog и пролога.
  • Как БД хранят данные внутри себя, append-only logs и структуры для индексов — очень подробное и понятное описание, мне конечно тяжело судить, но показалось, что настолько понятное, что его можно было бы читать даже без какого-то бэкграунда
  • Форматы хранения данных — текстовые, бинарные, рассуждения о forward и backward compatibility. Тут интересным было читать про Avro (опять-таки, потому что я с ним не сталкивался ранее 🙂

Вторая — распределенные данные и проблемы возникающие при этом

  • Репликация. Очень подробный обзор — синхронная / асинхронная, с одним лидером и без лидера, проблемы с лагом репликации и способы их решения
  • Партиционирование. Способы шардинга, распределённые индексы, ребалансировка, роутинг запросов.
  • Транзакции. Не просто что такое и зачем, но и трейдоффы, уровни изоляции и как они релизовываются на низком уровне.
  • Проблемы распределённых систем. Одна из самых полезных глав. Что и как может пойти не так — нестабильные сети, процессы на паузе, ненадежное время, разница между монотонным и календарным временем, Byzantine faults (не могу придумать как это корректно перевести на русский таким же коротким термином — возможно, в русском нет подобного термина для неполадок, вызванных поведением частей системы, которые нарочно врут и им нельзя доверять)
  • Распределенные транзакции — двухфазный коммит, алгоритмы консенсуса (без глубокого погружения, но общие принципы, и какие существующие инструменты их реализовывают)

Третья — пакетная и потоковая обработка данных

  • Пакетная обработка (batch processing) — MapReduce и описание какие есть способы осуществления джойнов данных при этом + рассуждения о том насколько оно похоже на Unix утилиты
  • Потоковая обработка (stream processing) — переход от пакетной обработки, message-based и log-based источники данных, change data capture, event sourcing и как и везде в книге — рассуждения о проблемах и трейдофах при потоковой обработке данных, а также как сделать её максимально ошибкоустойчивой (микробатчи, идемпотентность)
  • И последняя глава состоит из рассуждений автора о будущем обработки данных и этических вопросах. Второе неинтересно (т.к. ничего нового, всё те же опасения, и гос. регулирование нас спасёт), разве что стоит отметить сравнение текущего положения со сбором и обработкой данных с ранним капитализмом — детским трудом, 12-часовым рабочим днём и т.п.
    А вот техническая часть главы выглядит интереснее — кругом сплошное телевидение сплошные стримы и данные порождаемые из данных. Интересна идея замены двухфазного коммита на единое сообщение с бизнес-транзакцией пользователя, на основании которой уже все системы (базы данных, поисковые индексы, очереди сообщений и т.п.) делают нужные им изменения состояния, но автор сам отмечает, что тут есть большая проблема с read your own writes, которая по его мнению как-нибудь будет решена (мы же о будущем мечтаем).

В целом очень доволен, что прочёл. Главный плюс книги вижу ещё и в постоянном внимании к тому, что может пойти не так, и какие проблемы есть у таких и эдаких решений. Какая цена будет чтобы их избежать. И не дешевле ли будет позволить системе иногда ошибаться и разработать механизм устранения ошибок постфактум, особенно учитывая то, что информационная система работает с реальным миром, в котором ошибки все равно происходят, поставщики не доставляют товар (даже если он идеально записан во все БД), а сотрудники забывают про задачи клиентов (даже записанные с максимальной надёжностью и доставленные по всем каналам без потерь).

Улучшение оптимизатора запросов в MySQL 8.0.17 (по сравнению с 8.0.16)

Минорные релизы MySQL 8 совсем не минорные и у этого есть как минусы (в случае проблем откатиться обратно на предыдущий минорный релиз не выйдет), так и плюсы, т.к. в них появляются новые фишки и улучшения.

В 8.0.17 к примеру завезли оптимизацию запросов с NOT EXISTS:

The optimizer now transforms a WHERE condition having NOT IN (subquery)NOT EXISTS (subquery)IN (subquery) IS NOT TRUE, or EXISTS (subquery) IS NOT TRUE internally into an antijoin, thus removing the subquery.

Пример, имеем запрос:

SELECT task.TaskID
FROM contact
INNER JOIN login ON login.LoginID = contact.LoginID
INNER JOIN task ON task.TaskID = contact.TaskID
LEFT OUTER JOIN taskstar ON taskstar.TaskID = task.TaskID AND taskstar.LoginID = 858636
INNER JOIN taskaccess accesslogined ON task.TaskID = accesslogined.TaskID AND accesslogined.LoginID = 858636
WHERE 1
AND contact.ContactBool_1 = 0
AND contact.ContactSpam = 0
AND task.TaskType = 4
AND contact.ContactIsDeleted = 0
AND task.TaskIsDeleted = 0
AND (NOT EXISTS(SELECT 1
FROM task
WHERE ClientID = contact.ContactID
AND task.TaskIsDeleted = 0
AND (task.TaskType = 0)
AND task.TaskStatusSetID = 57450)
)
GROUP BY task.TaskID
ORDER BY task.TaskID
LIMIT 0,5

Выполняем его в MySQL 8.0.16 и получаем:

5 rows in set (1 min 9.92 sec)

Больше минуты, совсем некомфортно.
Обновляем MySQL и выполняем его же в 8.0.17:

5 rows in set (1.02 sec)

Профит 🙂