Сколько абстракции-это слишком много?
в объектно-ориентированной программе: сколько абстракции слишком много? Сколько раз?
Я всегда был гайки и болты вид парня. Я понимал концепцию высоких уровней инкапсуляции и абстракции, но всегда инстинктивно чувствовал, что добавление слишком многого просто запутает программу.
Я всегда пытался снимать для количества абстракции, которая не оставляла пустых классов или слоев. А где сомневаешься, вместо того чтобы добавить новый слой к иерархии, я бы попытался вписать что-то в существующие слои.
однако в последнее время я сталкиваюсь с более высоко абстрактными системами. Системы, где все, что может потребовать представления позже в иерархии, получает один фронт. Это приводит к большому количеству пустых слоев, что на первый взгляд кажется плохим дизайном. Однако, подумав, я понял, что оставляя эти пустые слои, вы получаете больше мест для подключения в будущем без особых проблем рефакторинг. Это оставляет вам больше возможностей для добавления новых функций поверх старых, не делая почти столько же работы, чтобы настроить старый.
два риска этого, кажется, что вы можете получить слои, которые вам нужны неправильно. В этом случае вам все равно нужно будет сделать существенный рефакторинг для расширения кода и все равно иметь тонну никогда не используемых слоев. Но в зависимости от того, сколько времени вы тратите на то, чтобы придумать начальные абстракции, шанс испортить его и время, которое может быть сохранено позже, если вы получите это право - это все еще может быть стоит попробовать.
другой риск, о котором я могу думать, - это риск переусердствовать и никогда не нуждаться во всех дополнительных слоях. Но разве это так уж плохо? Действительно ли слои экстра-класса настолько дороги, что это большая потеря, если они никогда не используются? Самые большие расходы и потери здесь - это время, которое теряется перед тем, как приступить к слоям. Но большая часть этого времени все еще может быть сохранена позже, когда можно будет работать с абстрагированный код, а не более низкоуровневый код.
Так когда это слишком много? В какой момент пустые слои и дополнительные абстракции "могут понадобиться" становятся излишними? Как мало это слишком мало? А где же сладкое местечко?
есть ли какие-либо надежные эмпирические правила, которые вы нашли в ходе своей карьеры, которые помогут вам судить о количестве необходимой абстракции?
8 ответов:
Так когда это слишком много? В какой момент сделайте пустые слои и дополнительную " мощь нужно, чтобы абстракции стали излишними? Как мало это слишком мало? Где сладкое местечко?
Я не думаю, что есть однозначный ответ на эти вопросы. Опыт необходим для развития чувства того, что "слишком много" и "слишком мало". Возможно, использование некоторых инструментов Метрики или контроля качества может помочь, но это трудно обобщить. Это в основном зависит от каждого случай.
вот несколько ссылок, которые могут вдохновить вас на поиски ответов:
- он тебе не понадобится
- парадокс использования/повторного использования
- треугольник проекта: хороший, быстрый, дешевый
- все проблемы в информатике могут быть решены с помощью другого уровня косвенности (Дэвид Уилер)
развитие-это все о нахождении правильного баланса между различными напряжениями, которые присутствуют в любом программном обеспечении инженерных усилий.
смысл абстракций заключается в фактор общие свойства из конкретных, как в математической операции:
ab + ac => a(b + c)теперь вы делаете то же самое с двумя операциями вместо трех. Этот факторинг сделал наше выражение проще.
типичным примером абстракции является файловая система. Например, вы хотите, чтобы ваша программа могла писать на многие виды устройств хранения данных: перьевые диски, SD-карты, жесткие диски, так далее...
если бы у нас не было файловой системы, нам нужно было бы реализовать логику прямой записи на диск, логику записи на ручку и логику записи на SD-карту. Но все эти логики имеют что-то общее: они создают файлы и каталоги, поэтому эти общие вещи можно абстрагировать, создавая уровень абстракции и предоставляя интерфейс поставщику оборудования для выполнения конкретных вещей.
чем больше вещей имеют общую собственность. Тем выгоднее абстракция может быть:
ab + ac + ad + ae + afto:
a(b + c + d + e + f)Это позволит сократить 9 операций до 5.
в принципе каждая хорошая абстракция примерно вдвое снижает сложность системы.
вам всегда нужно по крайней мере две вещи, разделяющие общее свойство, чтобы сделать абстракцию полезной. Конечно, вы разрываете одну вещь на части, так что это выглядит как абстракция, но это не значит, что это полезно:
10 => 5 * 2вы не можете определить слово "общие", если у вас есть только одна сущность.
Итак, чтобы ответить на ваш вопрос. у вас достаточно абстракций, если они делают вашу систему максимально простой.
(в моих примерах сложение соединяет части системы, а умножение определяет абстрактно-конкретное отношение.)
Как мало это слишком мало?
когда вы продолжаете работать с элементами" низкого уровня " на регулярной основе, и вы постоянно чувствуете, что не хотите этого делать. Отвлечься от них.
Так когда это слишком много?
когда вы не можете делать биты и куски некоторых частей кода на регулярной основе и должны отлаживать их до предыдущего уровня. Вы чувствуете, что этот конкретный слой ничего не вносит, просто препятствие. Уронить его.
где сладкое пятно?
Мне нравится применять прагматический подход. Если вы видите потребность в абстракции и понимаете, как она улучшит вашу жизнь, идите на это. Если вы слышали, что должен быть "официально" дополнительный уровень абстракции, но вы не понимаете, почему, не делайте этого, но сначала исследуйте. Если кто-то настаивает на абстрагировании чего-то, но не может ясно объяснить, что если принесет, скажите им, чтобы они ушли.
в теории, это должны вопрос простой математики, используя только три (довольно простой) переменные:
- S = экономия от использования
- C = стоимость дополнительных абстракций
- P = вероятность использования
Если S * P > C, то код хороший. Если S * P
причина, которая чисто теоретическая, однако, заключается в том, что вы обычно не можете догадаться о вероятности использования или экономии, которую вы получите от его использования. Хуже того, вы не можете догадаться или или обычно даже мера стоимость его присутствия.
по крайней мере, некоторые люди сделали вывод из этого. В TDD стандартная мантра - "вам это не понадобится" (YAGNI). Проще говоря, все, что не вносит непосредственного вклада в код, отвечающий его текущим требованиям, считается плохим. По сути, они пришли к выводу, что вероятность использования настолько низка, что в том числе такой дополнительный код никогда оправдано.
некоторые из них возвращаются к разработке" снизу вверх "по сравнению с" сверху вниз". Я склонен думать о разработке снизу вверх как о "разработке библиотек" - т. е. вместо разработки конкретного приложения вы действительно разрабатываете библиотеки для тех вещей, которые вам понадобятся в приложении. Думается, что с достаточно хорошей библиотекой вы можете относительно легко разработать практически любое приложение этого общего типа.
совсем немного также зависит от размера проекта. Огромные проекты, которые используются десятилетиями, оправдывают гораздо более долгосрочные инвестиции, чем небольшие проекты, которые отбрасываются и заменяются гораздо быстрее. Это имеет очевидные аналоги в реальной жизни. Вы не беспокоитесь почти так же о подгонке, отделке или мастерстве в одноразовой бритве, которую вы выбросите менее чем за неделю, как и в чем-то вроде нового автомобиля, который вы будете использовать в течение следующих нескольких лет.
проще говоря, есть слишком много абстракции, если код трудно понять.
теперь это не означает, что вы должны жестко закодировать все, потому что это самый простой код для записи и чтения.
самый простой тест - либо положить его на несколько дней, забрать его обратно и спросить себя, имеет ли это какой-либо смысл. Лучший подход-дать его кому-то другому и посмотреть, смогут ли они сделать из него орел или решку.
реальность такова, что это зависит от того, насколько хорошо вы можете заглянуть в будущее. Вы хотите планировать изменения, которые вы можете предвидеть, не создавая слишком много дополнительных слоев. Если у вас есть проект, который передает данные между системами, идите вперед и создайте интерфейс и используйте запланированную реализацию по умолчанию. Например, вы используете FTP для перемещения файлов, но знаете, что стандарт будет основан на сообщениях (или что-то еще) в следующем году.
Что касается слоев в дизайне, иногда добавляются слои облегчают написание небольших классов. Можно добавить концептуальные слои, если это означает, что конкретные классы становятся прямыми.
каждая абстракция, которая на самом деле не используется, слишком много. Чем проще система, тем легче ее изменить. Уровни абстракции почти всегда делают системы более сложными.
OTOH, конечно, можно запрограммировать сложный, недостижимый беспорядок без какой-либо абстракции, и иногда "стандартизированные" уровни абстракции могут помочь структурировать систему лучше, чем большинство людей смогут сделать самостоятельно.
см. пункт
(6a)на RFC 1925 и знайте, что это действительно так. Единственные проблемы, которые вы не можете исправить, добавив слои абстракции, - это те, которые вызваны слишком большим количеством слоев абстракции. (В частности, каждая часть абстракции делает все это более трудным для понимания.)
Comments