Приходилось ли вам когда-нибудь сделать шаг назад после двух шагов, чтобы сделать третий?
Это произойдет с вами, если вы попытаетесь написать код, пропуская эти 3 основных правила. Рано или поздно вы поймете важность овладения основами и мудрость их использования. Но не наполняйтесь, это путешествие никогда не заканчивается, и всегда есть что улучшить.
Когда друг спросил меня, в какой момент я считаю себя хорошим разработчиком, я ответил — НИКОГДА. Однако есть несколько общих правил, которые помогут вам создавать масштабируемые приложения. Они очень простые, но их стоит запомнить.
В программировании все сводится к трем основным правилам:
1. Делайте свой код простым, глупым
KISS — это аббревиатура от будь простым, глупым. Это принцип конструкции, отмеченный ВМС США в 1960 году. Принцип KISS гласит, что большинство систем работают лучше всего, если они остаются простыми, а не усложненными. Следовательно, простота должна быть ключевой целью в дизайне, и следует избегать ненужной сложности.
15 Строгих Правил, Которым Обязаны Следовать Профессиональные Фигуристки
KISS учат нас, что сложность не является признаком гениальности — это указывает на недостаток инвестиций. Это показывает неспособность разбить аспекты проблемы, чтобы найти решение, которое можно было бы представить и объяснить любому в двух предложениях.
Никакой инструмент не может решить проблему простоты. Подобно инструменту CodeClimate, он может найти ваши самые большие замедления и понять, где застревают запросы на вытягивание, но не может сказать вам, насколько хорошо ваш код определен или как его упростить. Вот почему каждый разработчик должен следить за тем, чтобы код был по-настоящему простым во время разработки.
2. Не повторяйся
DRY or Don’t Repeat Yourself — это принцип разработки программного обеспечения, основной целью которого является сокращение повторения кода.
Это подчеркивает важность предотвращения дублирования. Однако иногда повторение трудно заметить. Иногда мы повторяем код, чтобы привести его в соответствие с первым правилом, поскольку избавление от дублированного кода может потребовать большей сложности.
Обычно разработчики избавляются от дублированного кода, когда проводят рефакторинг по правилу трех. Это означает, что допустимо повторять один и тот же код один раз, но если вы сделаете это трижды, пора провести рефакторинг.
3. Состав
Композиция — объединение частей или элементов в единое целое.
Все дело в том, чтобы взять простые объекты и объединить их в более сложные. Чтобы построить автомобиль, вы должны определить функцию для создания основных элементов, таких как двигатель, конструкция или тормоза.
В случае Front-end разработки вам нужно будет перевести дизайн в код. Каждый дизайн состоит из визуальных элементов. Перед тем, как начать, разработчики пытаются определить, какие части этих элементов нужно превратить в компонент, а какие нет.
Правила, которым должны следовать все ходячие в “Ходячих мертвецах”
Следуя правилу композиции, вы будете стараться избегать создания очень сложных компонентов. Общее правило состоит в том, что каждый компонент должен делать только одно. Если вы обнаружите, что созданная вами небольшая деталь выполняет слишком много функций, вы, вероятно, захотите разбить ее на несколько компонентов. С другой стороны, если компонент делает слишком мало, вы, вероятно, захотите пропустить создание этого компонента или объединить его с другим.
Лучшая практика использования правила композиции — сначала идентифицировать компоненты, а затем воплощать их в жизнь, объединяя вместе в общую картину.
Вывод
Чтобы убедиться, что ваш код соответствует правилам KISS, DRY и Composition, я предлагаю написать для него тест — просто.
Довольно часто, когда вещи слишком сложны, их трудно проверить. Такой подход позволит вам писать более декларативный код, понятный каждому.
Из-за этого подхода я начинаю использовать monorepo для проектов, где вы можете использовать все эти правила и делиться большим количеством кода.
Monorepo значительно увеличивает возможность беспрепятственной работы между различными пакетами, их извлечения и совместного использования между веб-интерфейсом, серверной частью и другими сервисами.
Источник: digitrain.ru
10 важнейших принципов разработки программного обеспечения
Принципы разработки программного обеспечения необходимо знать каждому инженеру, который хочет писать чистый код. Следование этим принципам позволяет вам и другим разработчикам понять проект.
Кроме того, обслуживание или изменение проекта в будущем станет легким. Таким образом, вы в конечном итоге сэкономите деньги, время и ресурсы. Если вы хотите, чтобы проект развивался более плавно, то рекомендуется жить по этим законам.
10 основных принципов программирования, которым должны следовать все программисты
Просто люблю писать, переводить и давать людям возможность читать интересный контент. И пусть я не всегда идеальна — есть к чему стремиться.
Ваша роль как программиста заключается в написании кода, который работает должным образом и обеспечивает желаемый результат. Однако код также должен быть простым для понимания, поддержки и расширения. Чтобы справиться с этой задачей, вам необходимо объединить ключевые концепции программирования с принципами хорошего кодирования.
В этой статье мы поделимся 10 лучшими принципами программирования, которые помогут вам улучшить способ написания кода, что облегчит жизнь вам, вашим коллегам–разработчикам и конечным пользователям.
Почему важны принципы программирования?
Потратив время на изучение некоторых принципов программирования и дальнейшее их использование в своем коде, вы станете лучшим разработчиком. Следование этим рекомендациям повышает общее качество кода и облегчает вам или кому-либо еще внесение изменений или добавление функциональности в будущем.
Принципы программирования помогут вам избежать таких проблем, как беспорядочный или чрезмерно сложный код, программы, которые ломаются после одной настройки, и переменные, которые не имеют смысла. Соблюдение их также позволит вам более успешно сотрудничать, гарантируя, что другие программисты смогут понять ваш код.
Независимо от того, создаете ли вы базовую программу или приложение корпоративного уровня, стоит ознакомиться с этими 10 принципами.
1. Делай проще, тупица! (KISS)
Сохранение простоты и чистоты кода — один из важнейших принципов программирования. Некоторым разработчикам нравится хвастаться, написав слишком длинный или сложный код, но даже если это выглядит умно, код может быть не особенно понятным.
Вы всегда должны стремиться к тому, чтобы ваш код был легким для понимания – если вы можете написать скрипт в одну строку, то сделайте это! Вы можете разбить сложную задачу на более мелкие фрагменты или удалить какой-нибудь ненужный код. Цель состоит в том, чтобы уменьшить сложность и решить проблемы, а не произвести впечатление на людей.
Использование понятных имен переменных — еще один способ упростить задачу. Не забывайте пользоваться библиотеками кодирования и существующими инструментами.
2. Не повторяйтесь! (DRY)
Повторение — распространенная ошибка, потому что, если вы дублируете данные, логику или функцию, ваш код будет длинным, и на его поддержку, отладку или модификацию потребуется больше времени.
Повторение включает в себя копирование и вставку кода в вашу программу. Вместо дублирования строк лучше найти алгоритм, который вместо этого использует цикл, поскольку гораздо проще отладить один цикл, который обрабатывает 20 повторений, чем 20 блоков кода, каждый из которых обрабатывает одно повторение.
3. Вам это не понадобится! (YAGNI)
Вы не должны писать код исключительно на тот случай, если он вдруг может понадобиться в будущем. Другими словами, принцип YAGNI говорит вам писать код только для текущей ситуации, а не пытаться решить проблему, которой не существует здесь и сейчас.
Свойства и функционал следует добавлять только при необходимости, в противном случае ваше программное обеспечение станет больше и сложнее, чем это необходимо. YAGNI исходит из методологии разработки программного обеспечения Extreme Programming (XP), которая направлена на снижение неэффективности.
Программисты иногда нарушают этот принцип, пытаясь придерживаться методов кодирования DRY, поэтому убедитесь, что вы помните и о том, и о другом.
4. Документируйте свой код
Итак, вы написали свой код и понимаете его (надеемся!). Но только потому, что для вас он имеет абсолютный смысл, это не значит, что написанное будет понятно кому-то еще. Вы можете помочь своим коллегам-разработчикам, задокументировав свой код комментариями, а также улучшив имена ваших переменных и функций.
Например, если вы разрабатывали алгоритм маршрутизации вызовов для использования в решениях центров обработки вызовов VoIP, вы могли бы оставлять комментарии, объясняющие различные функции и облегчающие их понимание другими разработчиками или тестировщиками.
Все языки программирования предоставляют вам возможность прикреплять комментарии к вашему коду, поэтому вы должны сделать это своей привычкой. Да, это небольшая дополнительная работа, но она важна при сотрудничестве с другими. Кроме того, если вы вернетесь, чтобы изменить код через несколько месяцев, вы будете рады, что сделали это!
5. Композиция важнее наследования
Если вы повторно используете код, который уже написали, есть два способа сделать это: наследование и композиция. Большинство программистов предпочитают композицию (хотя наследование имеет свои преимущества, так что не игнорируйте его полностью).
Принцип композиции вместо наследования особенно полезен, если вы используете объектно-ориентированное программирование или ООП (которое на самом деле имеет свой собственный набор принципов). В нем говорится, что объекты со сложным поведением должны содержать экземпляры объектов с индивидуальным поведением – они не должны наследовать класс и добавлять новые модели поведения.
С наследованием фреймворки классов быстро становятся громоздкими, что приводит к появлению множества классов, которые могут соответствовать или не соответствовать вашим потребностям. Иерархии классов трудно изменить после их развертывания, поскольку вы не можете изменить суперкласс, не рискуя нарушить подкласс пользователя. И существует меньшая гибкость для определения поведения в особых случаях.
Композиционное программирование проще в написании и обслуживании, а также обеспечивает более простую и тестируемую кодовую базу. Оно позволяет определять гибкость поведения — вы можете создавать классы для легкого добавления или изменения и откладывать создание компонентов до тех пор, пока они не понадобятся.
6. Открыто/Закрыто
Если вы создаете библиотеку или фреймворк, которые будут использовать другие, важным принципом является «открытость/закрытость». Это означает, что программные артефакты, такие как классы и модули, открыты для расширения, но закрыты для модификации. Такой подход делает код более стабильным и простым в обслуживании.
Допустим, вас просят написать код для шаблона агентского соглашения компании, занимающейся разработкой программного обеспечения для электронной подписи. Вы выпускаете версию фреймворка, чтобы программисты могли напрямую изменять и интегрировать ваш выпущенный код. Но если вы выпустите крупное обновление в будущем, код будет нарушен. Лучше выпускать код, который поощряет расширение, предотвращая при этом прямое изменение, что сводит к минимуму риск появления новых ошибок.
7. Единственная ответственность
Этот принцип гласит, что каждый класс или модуль в программе должен предоставлять только одну конкретную функциональность, и не должно быть более одной причины для изменения класса. Цель состоит в том, чтобы избежать умножения побочных эффектов или обязанностей в одном методе или классе.
Классы усложняются, если вы добавляете слишком много обязанностей, и становится труднее создать дополнительную функциональность для конкретного модуля. Лучше разбить их на более мелкие классы и модули, чтобы было легче изолировать определенный модуль для устранения неполадок.
Единственная ответственность и открыто/закрыто являются частью принципов SOLID, изложенных Робертом Мартином (принципы объектно-ориентированного программирования).
8. Разделение ответственности (SoC)
Этот принцип программирования представляет собой абстрактную версию единой ответственности. SoC утверждает, что программа должна быть разработана с использованием разных контейнеров, которые не должны иметь доступа друг к другу. Каждый фрагмент кода полностью независим.
Это способ разделения сложного приложения на различные разделы или домены, каждый из которых выполняет определенную работу или решает разные проблемы. Такого рода подход упрощает обслуживание, обновление, повторное использование и отладку кода.
Хорошо известным примером является дизайн «Модель-Представление-Контроллер» (MVC), используемый в настоящее время в популярных веб-фреймворках. Программа разделена на три отдельных раздела – данные (модель), логика (контроллер) и то, что видит конечный пользователь (представление), — и каждый раздел обрабатывается независимо.
9. Минимизируйте связь
Кодовая связь — это когда два модуля или два уровня имеют определенную степень взаимозависимости, например, совместно используют код или имеют доступ к одним и тем же данным. Это может создать проблемы, в том числе код, который трудно отслеживать и поддерживать.
Например, если разработчик связывает свои конечные точки API с определенным представлением в интерфейсном приложении, таком как многоканальная телефонная система, конечная точка не может быть повторно использована для другого представления, такого как мобильное приложение.
Программистам необходимо понимать, как связан код, чтобы минимизировать взаимодействие, что включает в себя понимание обязанностей каждого уровня. Единственная ответственность также уменьшает взаимосвязь между отдельными компонентами программного обеспечения и кода.
10. Рефакторинг
Кодовые базы постоянно развиваются, поэтому будут моменты, когда вам потребуется пересмотреть, переписать или переработать целые фрагменты кода. Вместо того чтобы рассматривать это как неудачу вашей первой попытки, думайте об этом как о возможности учиться.
Рефакторинг кода означает его пересмотр и поиск способов оптимизации, повышения эффективности при сохранении точно таких же результатов. Однако вам следует избегать преждевременной оптимизации. Не оптимизируйте свой алгоритм на ранней стадии разработки, потому что вы не можете предсказать узкие места, а требования могут измениться.
В заключение
Если бы мы сократили этот список до одного ключевого принципа, он был бы таким: сделайте ваш код легким для понимания и обслуживания. Несколько принципов программирования в нашем списке преследуют эту цель, начиная с KISS и DRY до единственной ответственности и документирования вашего кода.
Следуя выше описанным принципам, вы сможете создать простой код, который делает то, что от него требуется, и понятен другим. Кроме того, вы будете знать подходящее время для его оптимизации. И последний совет – продолжайте учиться, чтобы продолжать совершенствоваться.
Всем успешной работы и творчества!
Источник: freelance.today