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

В этой статье мы рассмотрим лучшие практики, которые помогут нам стать лучшими разработчиками.

Непреднамеренное дублирование

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

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

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

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

Денормализованные данные можно нормализовать, и мы можем использовать уже существующие и протестированные решения, если уже что-то сделано.

Нетерпеливое дублирование

Мы можем копировать и вставлять что-то из-за нетерпения.

Это потому, что мы с чем-то возимся и хотим быстро это исправить.

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

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

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

Нам просто нужно очистить их, прежде чем мы доставим наш код.

Межразработочное дублирование

Несколько человек могут делать одно и то же, а мы этого не знаем.

Это может быть связано с тем, что мы не сообщили, что мы что-то делаем, или, возможно, мы забыли, что кто-то может делать то же самое, что и мы, даже если мы уже общались.

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

В любом случае мы должны информировать друг друга о том, что мы делаем, чтобы убедиться, что мы не делаем одно и то же.

Создание одного и того же для нескольких человек - пустая трата времени.

И поддерживать его позже также будет проблемой, поскольку нам придется поддерживать несколько реализаций одного и того же.

Было бы неплохо, если бы один человек координировал всю работу, чтобы убедиться, что ее не дублируют разные люди.

Таким образом, мы избегаем того, чтобы несколько человек неосознанно создавали более чем одно и то же.

Упростите повторное использование

Упрощение повторного использования вещей поможет в краткосрочной и долгосрочной перспективе.

Повторное использование означает, что нам не нужно делать то же самое снова, чтобы реализовать то, что в противном случае можно было бы использовать повторно.

Если это сложно, то люди этого не сделают.

Делаем вещи ортогональными

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

Это хорошо, поскольку мы не хотим делать что-то тесно связанное. Сильно связанные зависимости сломаются, если мы их изменим.

Поэтому мы не хотим, чтобы вещи были тесно связаны друг с другом.

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

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

Чтобы сделать вещи ортогональными, мы должны убедиться, что все независимо друг от друга.

Каждая вещь делает маленькую вещь, это четко определено. Пока мы не меняем интерфейс, который реализует вещь, нам не о чем беспокоиться.

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

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

Заключение

Нам нужно избавиться от дублирования в нашем коде и всего, что может иметь дублирование.

Дублирование не обязательно должно быть преднамеренным. Это также может быть непреднамеренным, поскольку люди могут непреднамеренно реализовать то же самое.

Следовательно, мы должны общаться, чтобы быть уверенными, что никто не делает то же самое.

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