Как часто вы должны рефакторинг?

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

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

вы пишете код с двумя шляпами. Элемент just-get-the-thing-working шляпа и Мне-нужно-понять-это-завтра шляпа. Очевидно, что вторая шляпа-это рефакторинг. Таким образом, вы рефакторируете каждый раз, когда вы что-то сделали, но (неизбежно) ввели запахи дублированного кода, длинных методов, хрупкой обработки ошибок, плохих имен переменных и т. д...

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

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

три веские причины для рефакторинга:

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

три веские причины не рефакторинг:

• "Это выглядит немного грязный".
• "Я не полностью согласен с тем, как последний парень сделал это".
• "Это может быть более эффективным". (Проблема есть 'мощь').

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

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

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

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

Как говорится в книге, вы рефакторинг, когда

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

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

Я стараюсь следовать этому девизу: оставьте весь код, который вы касаетесь лучше, чем это было.

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

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

Я рефакторинг, когда:

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

Я создаю новый код и после того, как я получил его "работы". Часто я буду работать, и когда я кодирую, я понимаю:"Эй, мне нужно переделать то, что я сделал 20 строк, только с несколькими изменениями". В этот момент я рефакторинг и продолжить.

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

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

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

например (тривиально), если я наткнулся

temp = array[i];
array[i] = array[j];
array[j] = temp;

Я бы, наверное, заменить с помощью метода swap(i,j).

компилятор, скорее всего, встроит его в любом случае, и swap() сообщает всем семантически, что происходит.

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

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

рефакторинг оппортунистически! Делайте это всякий раз, когда это легко.

Если рефакторинг затруднен, то вы делаете это в неправильное время (когда код не нуждается в этом) или в неправильной части кода (где есть лучшая эффективность, которую можно получить elswhere). (Или вы еще не настолько хороши в рефакторинге.)

сохранение рефакторинга для "обслуживания" является тавтологией. Рефакторинг и техническое обслуживание.

Я рефакторинг каждый раз, когда я читать что-нибудь и может сделать это более читабельным. Не крупная реструктуризация. Но если я думаю про себя: "что это List содержать? О,Integers!- тогда я поменяю его на List<Integer>. Кроме того, я часто извлекаю методы в IDE, чтобы поместить хорошее имя нескольких строк кода.

ответ всегда, но более конкретно:

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

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

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

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

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

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

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

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

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

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

с момента перехода на Squeak (который я теперь, кажется, упоминаю каждый пост) я понял, что многие вопросы дизайна во время прототипирования отпадают, потому что рефакторинг очень прост в этой среде. Честно говоря, если у вас нет среды, в которой рефакторинг в основном безболезнен, я рекомендую вам попробовать squeak, чтобы узнать, как это может быть.

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

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

некоторые цитаты, которые поддерживают его:

Дуглас Крокфорд, Старший Архитектор Javascript Yahoo:

рефакторинг каждый 7-й спринт.

Кен Томпсон (unix man):

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

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

изменить: орфографическая ошибка

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

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

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

в других ситуациях вы можете рефакторинг по мере необходимости. Например, при обнаружении повторяющегося кода.

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

Если он не сломался, не рефакторинг его.

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

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

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

Я думаю, что это топ-100 Wordpress блог может иметь некоторые хорошие советы. http://blog.accurev.com/2008/09/17/dr-strangecode-or-how-i-learned-to-stop-worrying-and-love-old-code/