Преодоление дурной привычки к “фиксации его позже”

«Сначала мы создаем наши привычки, затем они создают нас»

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

Практикуйтесь быть более модульными с самого начала, пока это не станет «таким, как я делаю».

Я придерживаюсь совершенно противоположного подхода, когда пишу что-то «на лету» без предварительного этапа проектирования. То есть я пишу основную функцию так, как она будет выглядеть «в идеальном мире», используя воображаемые объекты и методы, затем создаю скелеты всего, чтобы программа компилировалась, затем возвращаюсь и заставляю ее работать. Это обеспечивает модульную конструкцию, а высокоуровневый код очень прост для понимания. Во всяком случае, недостатком является то, что код может стать слишком модульным, так как соблазнительно написать doFoo () вместо реализации встроенного foo.

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

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

Мой подход - сверху вниз. Я пишу

while( obj = get_next_obj(data) ) {
  wibble(obj);
  fumble(obj);
  process( filter(obj) );
}

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

Таким образом я также избегаю комментировать алгоритмы : Имена функций являются достаточным объяснением.

Я считаю, что дисциплина TDD Red-Green-Refactor творит чудеса.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Рефакторинг намного менее страшен, если у вас есть хорошие инструменты для его выполнения. Я вижу, вы пометили свой вопрос как «C ++», но то же самое касается любого языка. Получите среду IDE, в которой легко выполнять извлечение и переименование методов, извлечение переменных и т. Д., А затем научитесь эффективно использовать эту среду IDE. Тогда «небольшой инкрементный рефакторинг», о котором упоминает Стефано Борини, будет менее пугающим.

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

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

Уловка состоит в том, чтобы провести рефакторинг как можно скорее, но не слишком рано. И часто, но не слишком часто. Как скоро и как часто? Поэтому это искусство, а не наука :)