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

Опубликовано: 24 Мая, 2021

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

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

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

Теперь у нас есть к вам несколько вопросов ...

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

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

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

1. Будьте последовательны

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

Например: если вы присваиваете имя переменной, такой как variableOne, variableTwo в своем приложении, выполните аналогичные действия в других местах. Для третьей переменной имя должно быть variableThree, а не variable_three. Позаботьтесь об этих мелочах.

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

2. Уменьшите вложенность

Часто разработчики пишут в своем коде операторы вложенности. Например ... запись оператора if внутри другого оператора if или if-else внутри другого оператора if-else. Часто становится очень запутанным читать и понимать код. Ваше приложение становится сложным и запутанным из-за структуры вложенности вашего кода.

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

// Без защитной оговорки

если (accountBalance! = ноль)
{
    если (getOrder! = ноль)
    {
        if (getOrder! = null.term == Срок годности)
        {
            // срок ежегодно
        }
        иначе, если (getOrder.term == Term.Monthly)
        {
            // срок ежемесячно
        }
        еще
        {
            выбросить новое исключение InvalidEnumArgumentException (nameof (term));
        }
    }
    еще
    {
        выбросить новое исключение ArgumentNullException (nameof (подписка));
    }
}
// С защитным условием
если (accountBalance! == null)
{
        выбросить новое исключение ArgumentNullException (nameof (account));
}
если (getOrder! = == нуль)
{
    выбросить новое исключение ArgumentNullException (nameof (order));
}
if (getOrder.term == Срок годности)
{
    // срок ежегодно (вернуться сюда)
}
если (getOrder.term == Ежемесячно)
{
    // срок ежемесячно (вернитесь сюда)
}
выбросить новое исключение InvalidEnumArgumentException (nameof (order.term));

3. Уменьшите масштаб и подумайте о картине в целом.

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

4. Именование вещей в вашем коде

Одна из самых сложных частей разработки программного обеспечения - это выбор подходящего имени для каждого фрагмента кода. Вам нужно внимательно следить за именами переменных, классов или методов. Например: если вы строите какой-то проект, в котором вы делаете некоторые вычисления для високосного года, вы можете дать ему имя «високосный год». Кто-то, кто собирается взглянуть на ваш код, обязательно поймет, что вы сделали что-то, связанное с leap_year.

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

5. Завышение

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

6. Документация и комментарии к коду

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

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

7. Удалите ненужный код.

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

8. Дайте время на проверку кода.

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

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

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

  • Если у вас небольшая задача с меньшим риском, то для проверки кода достаточно 1 разработчика.
  • Если у вас есть задачи среднего размера с большим риском или с большим количеством изменений, тогда 3-5 разработчиков могут просмотреть код, но один из них должен быть старшим разработчиком.
  • Если вы работаете над более рискованной задачей / изменением, договоритесь о встрече и пообщайтесь как минимум с 3 разработчиками. Кроме того, один из них должен быть ведущим разработчиком, который вместе просматривает каждую строку и проверяет точки.

9. Тестирование

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

10. Сосредоточьтесь на основах, а не на синтаксисе

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

У вас будет больше понимания проблем и программного обеспечения, когда вы усвоите основную концепцию. Это помогает в поиске проблем в Google и легком обнаружении ошибок в будущем.

11. Воспользуйтесь помощью Google.

Поиск проблемы в Google - не признак плохого разработчика. Это ум, а также повышает продуктивность разработчика. Хорошие разработчики - эксперты в гугле и решении проблем. Прочтите совет №4 еще раз. Разработчик, хорошо разбирающийся в фундаментальной концепции, знает, по каким терминам Google следует искать.

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

12. Заставьте это работать, а потом сделайте идеальным

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

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

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

13. Задавайте вопросы

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

Задавание вопросов устраняет всю путаницу, и это скорее признак любопытства, чем неспособности что-либо сделать.

14. ПОЦЕЛУЙ (Keep it Simple Stupid)

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

Последняя мысль

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

РЕКОМЕНДУЕМЫЕ СТАТЬИ