Pull to refresh

Comments 20

Дело осталось за малым: объяснить, почему раздутие кода в 2 с лишним раза — это хорошо.
Обычно этот момент очень слабо отражается в статьях по SOLID-у.
SOLID, как и паттерны — это рекомендация, а не жесткие требования. Это как совет общего назначения. Использовать вам что то оттдуда или нет — решать только вам. При написании кода всё ещё нужно думать головой. Не раздувайте код — и он не будет раздуваться.
Слабо отражается наверное потому, что это не важно. Даже не задумывался никогда об этом.
Предполагаю, вы видите проблему не в количестве «букв» на экране и диске, а в усложнении кода для поминая. Так вот, мне не кажется, что размер кода вообще связан с простотой понимания, по крайней мере линейно. Например, когда Sensors/FuelTank/etc. представлены отдельными классами — код проще и быстрее прочесть/понять вне зависимости от количества доп. кода и даже доп. сущностей. Разделение и упорядочивание, насколько мне известно — замечательный трюк для представления мозгу человека сложных вещей простыми.

Я бы упрощенно выразил смысл SOLID в контексте размера кода так:
Сложность (чтения/понимая/правки) спагетти-кода увеличивается экспоненциально, тогда как количество «букв» растет линейно. Сложность SOLID-based кода увеличивается линейно, хотя количество «букв» растет экспоненциально.

И выбор как бы очевиден. Когда не предвидится раздутия функциональности компонента — нам пофиг на экспоненциальный рост сложности. Можно не плодить дополнительных сущность.
Потому-что пишете код вы один раз, а читаете/редактируете/оптимизируете десятки и сотни раз. И уменьшая связанность кода, вы уменьшаете объём информации которую нужно будет перечитать и учесть при последующих модификациях.
Меньше вероятность сломать всё приложение при редактировании отдельного участка, меньше зависимостей нужно в итоге держать в голове.
Чтоб поменять топливный бак, например, вам нужно будет работать только с классом FuelTank а не искать где и как используется топливо по всей космической станции.
Вроде как этому моменту уделяется довольно много времени в обсуждениях SOLID.

Мне интересно, остались ли в аду котлы для наркобарыг? Мне кажется они забронированы для тех, кто цену всеми силами маскирует.


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


Некрасиво поступаете.

DIP (принцип инверии зависимостей) описан так, что больше путает, чем объясняет что это и зачем надо.
Модули верхних уровней не должны зависеть от модулей нижних уровней

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

Теперь о чём действительно говорит DIP:
  • Код, реализующий высокоуровневую политику, не должен зависеть от кода, реализующего низкоуровневые детали

Звучит похоже, но смысл совершенно другой.
На примере тех же карт, если вы хотите сделать свой код гибким, то вы должны выделить абстракцию MapImageInterface, содержащей допустим метод drawMap. Тогда реализация на яндекс картах, допустим YaMapImage будет имплементить этот интерфейс (это низкоуровневые детали). YaMapImage зависит от MapImageInterface, но не наоборот. Ваше приложение работает только используя MapImageInterface, не зная конкретных деталей (инстанцировать объект может например абстрактная фабрика). При этом код будет гибким и не будет проблем завтра добавить новую реализацию, например GoogleMapImage.

И раз уж вы описываете исключительно SRP, то и ограничьтесь его упоминанием в заголовке без кликбейта. SOLID не раскрыт.
Вообще, принцип инверсии зависимостей звучит как то так
Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций.
Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

Ок, если претендуем на точность, то нужна ссылка на источник. Могу назвать свой — Clean Architecture, Robert C.Martin, Chapter III — Design Principles:
The code that implements high-level policy should not depend on the code that
implements low-level details. Rather, details should depend on policies

Собственно Роберт Мартин это первоисточник в этом вопросе.
А если говорить о сути, то если бы в статье была часть про
Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций

То я бы не писал развёрнуто смысл, который был потерян.
Дело в смысле, а не в формулировке.
Никто не претендует на точность, я только хотел показать, что вот это
Модуль верхнего уровня всегда зависит от модуля нижнего уровня, который он использует.
не совсем верно, так как они оба должны зависеть от абстракций. По крайней мере я так понимаю принцип.
Мы оба понимаем принцип верно, просто говорим о разном.
Слово «модуль» оставляет большое пространство для фантазии и неправильного понимания, т.к. статья никак не раскрывает этот принцип.
Я хотел подчеркнуть, что использующий всегда зависит от используемого. На этом принципе строится граф зависимостей, позволяющий понять что вообще происходит с архитектурой в проекте.
В моём примере, проект, использующий карты, всегда будет от них зависеть.
Вопрос только в том, в каком виде — будет он зависеть от реализации, или от абстракции
И да, вы правы, в конце концов и проект и реализация будут завязаны на абстракцию.
В этом и инверсия, что вместо старого графа
  • проект -> реализация карт

Появляется инверсия от реализации к абстракции:
  • проект ->абстракция карт <-реализация карт
Ну, раз мы понимаем принцип одинаково (мое понимание), то вопрос закрыт. А в статье да, тема SOLID не раскрыта.
iss.supply_hold.use_supplies(«parts», 2)
iss.supply_hold.load_supplies(«parts», 10)


У описанного подхода, наряду с преимуществами, есть огромный такой подводный камень. Если внешние (по отношению к классу) сущности знают про ее составные части (supply_hold, thrusters, etc.), то практически невозможно предотвратить их повсеместное использование. И это через какое-то время приводит к тому, что код опять становится плохо тестируемым (= трудноподдерживаемым).

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

Так вот, если в этом примере код будет спускаться на уровень FuelTank-а каждого корабля, то создать моки для того, чтобы протестировать описанную логику, — будет очень, очень, очень громоздкой задачей. Как результат, на написание тестов часто будут «забивать» по причине горящих сроков, и в конце концов получится забагованный спагетти-код.

Нет, я не спорю, разделять сущности в соответствии с SRP — нужно. Но одновременно с этим вложенные сущности придется прятать в приватных полях, наружу выставляя более высокоуровневые методы (условно, GetFuelTanksCapacity(), GetFuelResidue()...). Это, в свою очередь, приведет к тому, что класс SpaceStation снова превратится в god object с множеством методов с совершенно различными обязанностями. Да, большинство этих методов будет тонкими обертками вокруг вложенных сущностей (a.k.a. паттерн фасад), да, этот класс будет сравнительно легко использовать в модульных тестах, но выглядеть он все равно будет страшно. Мало того, со временем разные потребители класса будут стремиться расширить класс еще более.

Отчасти это можно компенсировать при помощи принципа разделения итерфейсов: класс SpaceStation может реализовывать множество интерфейсов, в каждом из которых будет 1-2-5… методов, и внешний код будет работать с «толстой» сущностью только по «тонкому» интерфейсу, даже не зная, что работает с таким сложным божественным объектом. Но кода, увы, будет уже не в 2 раза больше, а раз этак в 6…

Увы, но у сложных проблем редко бывают простые решения, почти всегда что-то приносится в жертву.
Я думаю, что вот есть SOLID, есть паттерны, есть рекомендации, написано много книжек про всё это, и все эти вещи — они взаимосвязаны. То есть нет смысла искать какие то подводные камни в одном принципе. Есть же и рекомендации про сокрытие реалиации класса, и про DDD и прочее. К тому же, следование принципам не отменяет необходимости думать головой.
GetFuelTanksCapacity() это совершенно то же самое что и .FuelTanks.Capacity — потребитель знает, что у корабля есть топливный бак, у топливного бака есть вместимость.

Можно от этого абстрагироваться сделав на уровне корабля GetFuelDemand(), возможно, на уровне терминала тоже. Это позволит например, алгоритму расчета ничего не знать про корабли а на уровне космической станции добавлять свои потребности в топливе — а не только.

От god object можно избавляться по разному, см. например конйепцию, bounded context в ddd

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

Как только вы внесете такое изменение, ваши имена перестанут соответствовать ментальной модели.

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

Если не придерживаться этого правила, то по идентификатору нельзя будет понять, что собственно код призван делать и команде надо будет держать в голове набор правил типа «Мы не считаем топливный бак разгонного модуля частью топливных баков станции КРОМЕ, случая когда нам надо рассчитать их общую емкость» в этом люди будут путаться.
Разные контексты могут предполагать разные понимания одного термина в ментальной модели. Если контекст станции не интересует разделение вместимости баков на основные баки корабля и баки разгонного модуля, то и не надо их как-то делить или выделять, просто «вместимость баков». А вот в контексте корабля это деление может быть критически важным и там делим.
Не относится ли это к разнице между station.GetFuelTanksCapacity() и spaceship.GetFuelTanksCapacity() а не к разнице между station.FuelTanks.Capacity и station.GetFuelTanksCapacity()?

А нельзя будет сказать, что обязанностью станции будет агрегация данных кораблей? Ну или ввести отдельный класс агрегатора, сделав его ещё одним членом класса станции.

Sign up to leave a comment.