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

Ответ 1

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

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

Типичным решением таких проблем является уменьшение сцепления; делают разные части менее зависимыми друг от друга. У более опытных разработчиков иногда есть привычки или навыки проектирования, чтобы строить системы таким образом. Например, мы используем интерфейсы и реализации, а не классы; мы используем model-view-controller для пользовательских интерфейсов и т.д. Кроме того, мы можем использовать инструменты, которые помогут еще больше уменьшить зависимости, такие как "Зависимость впрыска" и аспектно-ориентированное программирование.

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

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

Ответ 2

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

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

Вы записываете модульные тесты? Если нет, вы регистрируетесь для длительных сеансов отладки при неудачном тесте.

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

Вы рефакторинг беспощадно? Если нет, каждое редактирование станет более сложным и более вероятным ввести ошибки. (Но сначала убедитесь, что у вас хорошие тесты.)

Когда вы исправляете ошибку, вы фиксируете весь класс? Не просто исправить ошибку; не просто исправить подобные ошибки во всем коде; измените игру, чтобы вы больше никогда не могли создавать такую ​​ошибку.

Ответ 3

• Существует два способа написания программ без ошибок; работает только третий. ~ Алан Дж. Перлис

• Единственный способ для ошибок, возникающих в программе, заключается в том, что автор помещает их туда. Других механизмов не известно. Программы не могут получить ошибки, сидя рядом с другими багги программами. ~ Харлан Миллс

Ответ 4

Ошибки - это большое дело для всех. Я всегда находил, что чем больше я программирую, тем больше я узнаю о программировании в целом. Я сжимаю код, который я написал несколько лет назад! Я начинал как любитель и так любил его, что поступил в инженерный колледж, чтобы получить крупную компьютерную инженерию (я в своем последнем семестре). Это то, что я узнал:

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

• Независимо от того, на каком языке я пишу, сохранение моего кода просто и доступно для чтения. Я считаю, что чрезвычайно важно не усложнять код и в то же время не упрощать его. (Жесткий урок!)

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

• Детали, зависящие от языка обучения, помогают мне избавиться от ошибок кода. Например, я узнал, что scanf() является злом в C!

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

• Хранение ментальной картины кода трудно порой, поэтому я всегда документирую свой код.

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

• Мышление перед тем, как я закоучусь и дисциплинирован в том, что я пишу, - еще одно важное умение. Я знаю людей, которые не форматируют свой код так, чтобы его читали (Shudder!).

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

• Не анализируйте паралич. Напишите тесты, затем код, затем выполните и проверьте. Повторное промывание повтора!

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

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

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

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

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

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

• Как сказал Джей Бадзузи - код Refactor. Я просто добавил этот момент после прочтения его ответа, чтобы закончить мой список. Все кредиты идут ему.

• Попробуйте написать многоразовый код. Код повторного использования, как ваш, так и из библиотек. Использование библиотек, которые не позволяют выполнять некоторые общие задачи, действительно уменьшает количество ошибок (иногда).

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

Не обижайтесь на всех, кто не согласен. Надеюсь, этот ответ поможет.

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

Ответ 5

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

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

Ответ 6

Все остальные ответы велики. Я добавлю две вещи.

• Контроль источника обязательный. Я предполагаю, что вы здесь. VisualSVN Server бесплатно и возможно 4 клика для установки. TortoiseSVN также является бесплатным и интегрируется в Windows Explorer, обойдя ограничения VS Express без надстроек. Если вы создаете слишком много ошибок, вы можете вернуть код и начать все заново. Без контроля источника это практически невозможно. Кроме того, вы можете синхронизировать свой код, если у вас есть ноутбук и рабочий стол.
• Люди собираются рекомендовать многие методы, такие как модульное тестирование, издевательство, инверсия контроля, тестирование Driven Development и т.д. Это отличная практика, но не пытайтесь слишком быстро втиснуть все это в вашу голову. Вам нужно написать код, чтобы лучше писать код, поэтому медленно используйте эти методы в написании кода. Вы должны ползать, прежде чем идти и ходить, прежде чем вы сможете бежать.

Удачи в ваших приключениях в кодировании!

Ответ 7

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

Ответ 8

Если ошибки не были проблемой, я мог бы написать программу на 100 000 строк за 10 минут!

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

Да: это центральная проблема, даже единственная проблема (для любого достаточно всеобъемлющего определения "ошибка" ).

Ответ 9

Ошибки являются общими для всех - профессиональными или нет.

Чем больше и более распределен проект, тем более осторожным должен быть. Один взгляд на любую базу данных с открытым исходным кодом (например: https://bugzilla.mozilla.org/) подтвердит это для вас.

В индустрии программного обеспечения развились различные programming styles и которые при правильном использовании делают неправильный код более легким для определения или ограниченности его воздействия.

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

Ответ 10

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

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

• Поверните магические строки в константы. То есть вместо использования:

  люди [ "мама" ]

используйте

var mom = "mom";
people[mom]

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

Крайне короткое и удобоваримое взятие ООП здесь http://www.holub.com/publications/notes_and_slides/Everything.You.Know.is.Wrong.pdf. Если вы получите это, у вас есть суть ООП и откровенно опережаете множество профессиональных программистов.

Ответ 11

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

Программисты Subpar, как правило, создают больше ошибок.

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

Ответ 12

Унылые ошибки случаются со всеми от профессионалов к любителям. На самом деле хороших программистов попросят отследить действительно неприятные ошибки. Это часть работы. Вы узнаете, что сделали это как разработчик программного обеспечения, когда вы смотрели на неприятную ошибку в течение двух дней и в отчаянии кричали: "Кто написал это дерьмо!?!?"... только осознать, что это вы.: -)

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

Все, что сказало, вот несколько вещей, которые вы можете сделать:

• Хороший отладчик неоценим. Часто вам нужно пройти свой код по строкам, чтобы выяснить, что пошло не так.
• Используйте собранный мусором язык, такой как Python или Java, если это имеет смысл для вашего проекта. GC поможет вам сосредоточиться на том, чтобы заставить вещи работать, вместо того, чтобы увязнуть в сумасшедших ошибках памяти.
• Если вы пишете С++, научитесь любить RAII.
• Введите LOTS кода. Программное обеспечение представляет собой нечто вроде художественной формы. Много практики сделают вас лучше на этом.

Добро пожаловать в переполнение стека!

Ответ 13

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

Ответ 14

Если вы плохо организованы, ваша кодовая база станет вашей собственной Zebra Puzzle. Добавление большего количества кода похоже на добавление большего количества людей/животных/домов в вашу головоломку, и вскоре у вас будет 150 различных животных, людей, домов и сигаретных брендов в вашей головоломке, и вы поймете, что вам потребовалась неделя, чтобы добавить 3 строки кода, потому что все так взаимосвязано, что требуется навсегда, чтобы убедиться, что код по-прежнему выполняется так, как вы хотите.

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