Как сделать код модульным?

Ответ 1

Некоторые тесты для модульности:

• Сколько раз вы переписываете аналогичный код для выполнения конкретной задачи?
• Сколько кода вам нужно реорганизовать свой код, если вы что-то измените где-нибудь в части своего программа?
• Доступны ли файлы меньше и проще?
• Являются ли прикладными модулями адекватно и независимо выполняются по мере необходимости?
• Насколько менее катастрофическим является ваш код? Все ли адский прорыв теряется, когда вы удаляете только одну функцию или переменную? Получаете ли вы 20 с лишним ошибок при повторном присвоении имени классу? (для экземпляра вы можете реализовать механизм стекирования, чтобы отслеживать все перелеты в вашем приложении)
• Насколько близок код к использованию естественного языка (т.е. модули и их подкомпоненты представляют собой более объекты реального мира, не придавая большого значения размеру чистого исходного файла).

Для большего количества идей проверьте это, а это на качество программного обеспечения

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

Каждый метод в вашем приложении должен выполнять не более минимальных квантов обработки, необходимых. Объединение этих методов во все больше и больше методов макроуровня должно привести вас к вашему приложению

Ответ 2

Ключевые моменты

• Разделение проблем
• Сплоченность
• Инкапсуляция (связь через интерфейс)
• подставляемость
• Повторное использование

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

Чтобы ответить на ваш вопрос: "Как я могу решить, какой конкретный код является модульным до такой степени", мы можем задать вопросы для проверки модульности. Можете ли вы легко заменить свои модули чем-то другим, не затрагивая другие части вашего приложения?

Анализаторы XML могут быть другим примером. Как только вы получите интерфейс DOM, вам все равно, какая реализация парсера XML используется под ним (например, Apache Xerces или JAXP).

В Java может возникнуть еще один вопрос: Доступны все функциональные возможности через interface s?. Интерфейс в значительной степени заботится о низком соединении.

Кроме того, можно описать каждый модуль в вашей системе одним предложением? Например, стереосистема воспроизводит музыку и радио. Тормоза диска тормозят автомобиль безопасно.

(Вот что я написал в Что такое разработка, основанная на компонентах?)

Согласно Wikipedia, компонентное развитие является псевдонимом для Разработка программного обеспечения на основе компонентов (CBSE).

[Это] является подразделением программного обеспечения техники, приоритетом которой является разделение озабоченностей в отношении широкой функциональности доступный во всем данном программном обеспечении система.

Это несколько расплывчато, поэтому давайте рассмотрим более подробную информацию.

Индивидуальный компонент - это программное обеспечение пакета или модуля, который инкапсулирует набор связанных функции (или данные).

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

Итак, согласно этому определению, компонент может быть любым, если он делает что-то очень хорошо и только одно.

Что касается общесистемного координация, компоненты связи друг с другом через интерфейсы. [...] Этот принцип приводит к компонентам, называемым инкапсулированными.

Итак, это все больше напоминает то, что мы думаем о хорошем API или SOA, должно выглядеть.

Представленные интерфейсы представлены леденцом и требуемые интерфейсы представлены символом открытого сокета, прикрепленным к внешнему краю компонента в UML.

alt text http://upload.wikimedia.org/wikipedia/commons/e/e1/Component-based-Software-Engineering-example2.gif

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

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

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

Идея в объектно-ориентированном программирование (ООП) - это программное обеспечение должны быть написаны в соответствии с ментальная модель фактического или воображаемого объекты, которые он представляет. [...]

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

Ответ 3

Чтобы ответить на ваш конкретный вопрос , как сделать код более модульным, существует несколько подходов:

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

• Определите, какие части логики могут быть сделаны независимыми, в том смысле, что другая логика будет использовать их без необходимости знать, как они создаются. Это несколько похоже на то, что вы делаете в OO-дизайне, хотя модуль/компонент необязательно должен соответствовать моделируемому объекту, как в OO.

Ответ 4

Хей,

См. "Как инкапсулировать программное обеспечение (часть 1)" здесь:

http://www.edmundkirwan.com/encap/overview/paper7.html

Привет,

Под ред.

Ответ 5

Поскольку это было помечено как "osgi", я могу использовать перспективу, связанную с OSGi.

Короткий ответ заключается в том, что можно перейти от полностью спагетти кода к модульной в малых шагах; это не должно быть большой взрыв. Например, даже код спагетти зависит от какой-то библиотеки журналов болонского звучания, поэтому в некотором смысле он уже модульный, просто с одним очень большим Metball (извините, модуль) в нем.

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

Что касается OSGi, все равно можно поместить uber-jar в пакет. Фактически, вы можете сделать это без изменения бит; либо путем модификации Manifest.MF на месте, либо путем обертывания этого в другом JAR и указания Bundle-ClassPath: metaball.jar в манифесте.

В противном случае такие инструменты, как BND, могут помочь сгенерировать нужные вам данные, а затем его можно будет легко удалить в среде OSGi. Но будьте осторожны с чрезмерно связанным кодом и тем, что галочки вокруг с загрузчиками классов - они вас отпустят.

Ответ 6

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

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

Ответ 7

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

Я бы сказал: Можете ли вы использовать данный метод в любой программе, где вам нужно выполнить эту функцию? Это "черный ящик", где вам не нужно было знать, что он делает под капотом? Если ответ отрицательный, то есть метод будет работать только в этой программе, тогда он не является действительно модульным.

Ответ 8

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

IMHO, если у вас есть 3 модуля A B и C, и вы хотите полностью или полностью заменить модуль C, если это простая задача, тогда у вас есть модульный код.

Ответ 9

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

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

Рамки внедрения зависимостей, такие как Spring, также могут помочь в модульности вашего дизайна. Поскольку типы вводятся своими зависимостями посредством некоторого внешнего процесса настройки, им не нужна прямая зависимость от реализации.

Ответ 10

поэтапная идея позволяет сделать код более модульным.

Множество примеров, видимых в Интернете, делят приложения сначала на слои, а не на функции

• Модели
• доступ к данным
• пользовательский интерфейс

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

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

Обычно удаление функции в таком приложении может быть реализовано за одну операцию - удаление одного каталога.