Неисправленная вовремя ошибка в коде может привести к разным последствиям. В
отдельных случаях это может очень критично отразиться на работоспособности всей
программы.
Что самое интересное, многие разработчики: как опытные, так и новички, иногда
оставляют решение некритичных ошибок «на потом», считая что потом появится
время их решить. Но как известно «на потом» – это значит «никогда». Потому что
если ошибка некритичная, то и приложение функционирует нормально, а значит
про сам баг со временем просто забывают. А любая неисправленная вовремя
ошибка — это как мина замедленного действия: она может «рвануть» в любое
время, а когда никто не знает, но в то же время может и не рвануть вообще.
Мы приведем несколько причин, почему всегда нужно вовремя исправлять ошибки в
коде и к чему может привести их игнорирование.
К чему приводит неисправленная вовремя ошибка в
программе?
- Не исправленная вовремя ошибка прячет в себе новые баги. Такая ситуация
незаметна сразу. Но любая проигнорированная ошибка может провоцировать
возникновение новых. Это заметно, когда вы вспомнили о забытом баге и
«пошли» исправлять тот участок кода, где находится баг. Вы его исправили —
участок кода работает хорошо. Но со временем начинают «всплывать» новые
баги, которых раньше не было — это и есть «скрытые» ошибки, которые
возникли из-за игнорирования «некритичного бага». Любой некритичный баг
может вскрывать или провоцировать возникновение критичных багов, поэтому
исправляете их сразу. - Неисправленная вовремя ошибка влияет на качество кода. Любой
программист хочет, чтобы его код был идеален. Но если в коде есть не
исправленный баг, то это как индикатор, что можно писать код некачественно,
потому что и с багом все работает. Представьте что над кодом работают
несколько разработчиков. Все стараются. Но в какой-то момент один из
разработчиков решил не исправлять некритичный баг. Через время другой
разработчик его увидел и решил тоже не исправлять свой некритичный баг,
потому что он увидел, что так можно делать. И так продолжается со всеми
членами команды. Со временем общее качество кода ухудшится, а в команде
будет «висеть» вопрос: «А нужно ли вообще стараться?». Поэтому любая не исправленная вовремя ошибка ухудшает код и ослабляет рабоче состояние
команды. - Неисправленная вовремя ошибка — это лишние разговоры. Когда
накапливаются нерешенные баги, наступает момент когда происходит
разговор на темы: «Откуда появились нерешенные баги?», «Кто
спровоцировал их возникновение?», «Почему не исправили вовремя?», «В
какой последовательности нужно все исправлять?» и т. д. Лишние разговоры
— это даром потраченное время, которое можно использовать с пользой.
Поэтому, чтобы не тратить время на пустые дискуссии, просто исправляйте
вовремя свои ошибки. - Не исправленная вовремя ошибка — это всегда дополнительная работа. И
чем больше их накапливается, тем больше времени они требуют. К примеру,
когда в процессе работы накопилось штук 60 ошибок и кто-то заявляет о 61-й,
то, элементарно, много времени тратиться на то чтобы просто просмотреть, а
есть ли данная ошибка в отчетах об уже известных багах? - Ошибка, которая не исправлена вовремя, всегда ухудшает общую статистику.
Сколько существует команд разработчиков, столько существует и способов
отслеживать ошибки в программировании. В командах, где об ошибке
записывают всю информацию: от ее значимости и до времени жизни, а потом
эти показатели переносят на общую эффективность команду, любая
неисправленная вовремя ошибка приводит к искажению данных и ухудшению
общей статистики работы команды. - Нерешенная ошибка всегда отвлекает. Простая ситуация: программист
дополняет чей-то код и находит старый баг. В голове его сразу возникает куча
вопросов: «Кто допустил?», «А можно ли так продолжить работу?», «А должен
ли я ее исправлять или исправить должен тот кто ее допустил?», «А нет ли
еще подобных ошибок в коде?» и т. д. Поиск ответов на все эти вопросы
всегда отвлекает от основной работы — коддинга. - Неисправленная вовремя ошибка может сорвать релиз. Представьте
ситуацию, что нужно срочно выпустить обновление программы или
представить заказчику рабочую версию нового продукта в сжатые и
ограниченные сроки. Это всегда будет стрессом для всей команды, так как
нужно сгруппироваться и поднатужится. Но тут всплывает, что у программы
присутствует большое количество нерешенных багов, которые тоже нужно
решить до релиза. Поэтому прибавляется еще больше работы, а значит есть
вероятность что-то не успеть. - Ошибки срывают сроки. Если продолжить пункт со сорванным релизом. Такая
ситуация может сложиться не только в критичной ситуации с ограниченным
временем. Но даже в обычном темпе разработке, есть вероятность сорвать
сроки из-за не вовремя исправленной ошибки. Разные баги требуют разного
времени на их решения. Некоторые решаются за считанные секунды, другие
за минуты, третьи за часы, а некоторые могут решаться днями. В какой
категории ваша не исправленная вовремя ошибка пока не известно. - Чем дольше не исправляется баг, тем сложнее его будет исправить в будущем.
Когда баг обнаружен в «свежем» коде, то и исправить его легче. Потому что
если пройдет 2-3 недели, то код, где содержится баг, забудется и станет
непонятным и «размытым». Это естественно, потому что прошло время, а
после «того» написанного кода вы писали еще много чего и мозг просто
подзабыл, поэтому придется заново разбираться что там и как.
Возможно вам будет интересно почитать статью “Какой выбрать CDN для сайта.”
Заключение
Неисправленная вовремя ошибка может ничего в себе не нести, а может принести
кучу разных проблем. Поэтому откладывать «на потом» – это большой риск. Вывод
только один: если нашли ошибку в коде, даже если она незначительная, то всегда
исправляйте ее сразу.