Как сохранить мою исправность при поддержании [закрытого] запутанного кода

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

Вы хотели бы читать

Работа эффективно с унаследованным кодом

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

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

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

Единственным путем я знаю:

1. тесты записи
2. осуществить рефакторинг
3. запустите тесты
4. зафиксируйте то, что повреждается
5. тесты записи на новую возможность
6. представьте новую возможность
7. запустите тесты
8. зафиксируйте то, что повреждается

Можно пережить его этот путь.

Примечание: существуют несколько раз, где это действительно твердо к запутанному коду модульного теста: 3Klines методы, которые генерируют HTML, ДАО, запутанные с бизнес-логикой, сильно связанные классы... в этом, заключают хороший IDE в корпус с автоматическим рефакторингом (способный к извлечению методов, для начала), и некоторые инструменты тестирования как Селен могут войти действительно удобные.

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

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

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

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

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

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

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

Я был достаточно успешен с этим подходом, что я получил почетный заголовок "Судебный Программист", это - также фантастический навык, чтобы иметь, потому что, как правило, новое задание уже имеет некоторый записанный код :P

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

Я знаю, что в известной страховой компании раньше делал sys администратора для, основная используемая ценовая система 25ish мейнфрейм года под названием GenZ. С середины девяностых я думаю, новая система была в разработке и в настоящее время реализована в бета-версии

Мейнфрейм, вероятно, работал отлично в 1980-х - но так как компания выросла, больше данных было добавлено, и система должна была содержать больше. Патчи были применены, больше проблем происходило, и его бывшее похожее это в течение многих лет.

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

Теперь, когда новая система (названный Maxx) реализована, несколько сотен приложений должны будут быть постепенно сокращены.

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

• Будьте медленными и преднамеренными.
• Тесты записи, когда Вы можете, но не становиться встревоженными, когда Вы не можете. Запутанный код является редко тестируемым кодом.
• Помните, что все, кто отредактировал код, прежде чем у Вас было серьезное основание сделать то, что они сделали. Примите лучшего из них, и Вы будете, вероятно, вознаграждены.
• Поймите код, прежде чем Вы попытаетесь изменить код.
• Сделайте заметки, как Вы узнаете и совершенствуете их, как Вы работаете. Сохраните и совместно используйте их на Wiki, если Вы можете.
• Используйте систему управления версиями, делайте каждое изменение максимально небольшим и сфокусированным, и регистрация максимально часто.
• Не в свои сани не садись. Поскольку Вы вносите одно изменение, Вы несомненно найдете что-то еще, что должно быть очищено. Добавьте его к своему списку текущих дел и останьтесь сфокусированными на своей исходной миссии.
• Рассматривайте проект как кемпинг: оставьте его в лучшем условии, чем Вы нашли его. И помните, что "лучше" относительно; Вы не можете зафиксировать все сразу.

outsauce это :)

Если это не опция, хорошо... сначала, попытайтесь сделать головы и хвосты ее. Для материала я имел дело с, это часто - самая твердая часть. Можно вручную создать UML, можно использовать некоторые коммерческие инструменты "инженерного анализа" исходного кода, или можно просто проследить код.

Когда у Вас есть понимание кода, пора осуществить рефакторинг. Запланируйте хорошо. Попытайтесь записать набор достойных тестов. Затем пройдите итерационный подход рефакторинга, записи дополнительных тестов и проверки (работающий!) модификации назад в управление исходным кодом.

В зависимости от того, насколько мазохистский Вы, это может быть отличным развлечением или Вашим собственным персональным адом :)

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

Ну, возможно, это просто помещается в мой случай, но здесь он идет:

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

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

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

Что ж, мне нужно переработать кошмарный веб-сайт, написанный на coldfusion, javascripts, html, и использовать пару плагинов ... Я единственный оставшийся разработчик этого приложения. Был переведен последний человек, обслуживающий сайт и базу данных. Я застрял с этим уродливым зверем. Я переработал некоторые файлы и функции, но проблемы и ошибки продолжают возникать.

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

Некоторые файлы состоят из 8k строк, потому что предыдущий разработчик (не настоящий разработчик) сохранял копирование и вставку фрагментов кода вместо разделения функций. Это очень тесно связанный код, небольшое изменение в одном файле потребует изменений в других местах от 4 до 5.

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

Я добираюсь туда по одному, извлекая и тестируя код с основного веб-сайта (локально).