Разработка на основе тестов и парное программирование [закрыто]

StackOverflow https://stackoverflow.com/questions/882661

Вопрос

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

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

Как мне убедить его, что оба они дополняют друг друга, а не ортогональны?Или я ошибаюсь?

Это было полезно?

Решение

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

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

Другие советы

Парное программирование эффективно при изучении новой практики особенно TDD

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

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

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

  • Улучшенное качество - Сопряжение стимулирует просмотр кода.Многие ошибки обнаруживаются по мере их ввода.Парное программирование означает непрерывный анализ кода, выполняемый двумя людьми, которые следят за качеством кода и постоянно работают вместе над выявлением и исправлением ошибок.Исследование, проведенное Университетом Юты, показало, что конечное количество дефектов, обнаруженных в коде, сократилось в среднем на 15% для кода, написанного парами.
  • Меньше времени тратится на "Застревание" - Программирование - это сложно.Часто разработчики изо всех сил пытаются найти решение и тратят больше времени, чем следовало бы, на "застревание".Наличие партнера, с которым можно провести мозговой штурм идей и согласиться обратиться за помощью в случае необходимости, сокращает количество непродуктивного времени, затрачиваемого на попытки найти решение.
  • Меньше времени тратится на отвлекающие факторы - разработчик с меньшей вероятностью тратит время на личные телефонные звонки, веб-серфинг или отпуск по электронной почте, когда он или она работает с партнером.
  • К проблеме применяются два подхода: разный уровень опыта, разные стили решения проблем, разные вспомогательные навыки - все это увеличивает шансы решить проблему быстрее.Исследование, проведенное Университетом Юты, также выявило лучший общий дизайн и меньшую длину кода для программного обеспечения, написанного парами.
  • Меньше страха перед неизвестным - В паре с другим разработчиком легче решить проблему или попытаться освоить новую технологию, чем при работе в одиночку.Со временем они также получают гораздо лучшее представление обо всем приложении.В конце концов, проект заканчивается тем, что несколько человек понимают каждую часть системы в результате сопряжения.
  • Менее вероятно расширение области видимости - часто разработчики охотно добавляют функциональность, не предусмотренную требованиями.При работе в паре второй разработчик с большей вероятностью будет отвлекать своего партнера от выполнения задачи.
  • Улучшенная командная динамика - благодаря парному подходу люди учатся работать вместе.Они чаще разговаривают и лучше воспринимают поток информации.В результате улучшается командная динамика.Фактически, мы обнаружили, что лучший способ создания команды - это совместная работа над созданием программного обеспечения, которое понравится вашему клиенту.Всем нравится быть частью успешной команды.
  • Устранение разрозненных знаний – Знания предметной области, кода или практических приемов быстро распространяются через команду и пару разработчиков друг с другом на основе ротации.

Как только команда освоится со спариванием, переходите к TDD.За этим следует уничтожение:

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

Разработка, основанная на тестировании, требует, чтобы автоматизированный модульный тест, определяющий требования к коду, был написан перед каждым аспектом самого кода.Эти тесты содержат утверждения, которые являются либо истинными, либо ложными.Выполнение тестов дает быстрое подтверждение правильного поведения по мере развития кода и его рефакторинга.Платформы тестирования, основанные на концепции xUnit, предоставляют механизм для создания и запуска наборов автоматизированных тестовых примеров.Цикл разработки, основанный на тестировании:Следующая последовательность основана на книге Test-Driven Development by Example, которую многие считают каноническим исходным текстом по концепции в ее современной форме.

  1. Напишите тест.При разработке, основанной на тестировании, каждая новая карточка истории начинается с написания теста.Этот тест завершится неудачей, поскольку он был написан до того, как функция была реализована.Чтобы написать тест, разработчик должен четко понимать спецификацию и требования к функции.Это может быть достигнуто с помощью карточек рассказов с критериями приемлемости, чтобы указать, когда требования были выполнены.Это также может подразумевать инвариант или модификацию существующего теста.Это отличительная черта разработки, основанной на тестировании, от написания модульных тестов после написания кода:это заставляет разработчика сосредоточиться на требованиях перед написанием кода, что является тонким, но важным отличием.
  2. Запустите все тесты и посмотрите, не сработает ли новый.Это подтверждает, что тестовый жгут работает правильно и что новый тест не проходит по ошибке, не требуя какого-либо нового кода.Новый тест также должен завершиться неудачей по ожидаемой причине.Этот шаг проверяет сам тест с отрицательным результатом:это исключает возможность того, что новый тест всегда пройдет успешно и, следовательно, будет бесполезен.
  3. Напишите какой-нибудь код.Следующий шаг - написать некоторый код, который приведет к прохождению теста.Новый код, написанный на этом этапе, не будет совершенным и может, например, пройти тест неэлегантным образом.Это приемлемо, потому что последующие шаги улучшат и отточат его.Важно, чтобы написанный код предназначался только для прохождения теста;никакая дальнейшая (и, следовательно, непроверенная) функциональность не должна быть спрогнозирована и "разрешена" ни на каком этапе.
  4. Запустите автоматизированные тесты и убедитесь, что они прошли успешно.Если все тестовые случаи теперь пройдут успешно, программист может быть уверен, что код соответствует всем тестируемым требованиям.Это хорошая точка, с которой можно начать заключительный этап цикла.
  5. Рефакторинг кода.Теперь код может быть очищен по мере необходимости.Повторно запуская тестовые примеры, разработчик может быть уверен, что рефакторинг не наносит ущерба какой-либо существующей функциональности.Концепция устранения дублирования является важным аспектом разработки любого программного обеспечения.В этом случае, однако, это также относится к удалению любого дублирования между тестовым кодом и производственным кодом — например, магических чисел или строк, которые повторялись в обоих, чтобы выполнить тест на шаге 3.

Повторять

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

Стиль разработки Существуют различные аспекты использования разработки, основанной на тестировании, например принципы "Будь проще, глупец" (KISS) и "Тебе это не понадобится" (YAGNI).Сосредоточившись на написании только кода, необходимого для прохождения тестов, проекты могут быть чище и понятнее, чем это часто достигается другими методами.Разработка, основанная на тестировании, требует, чтобы программист сначала провалил тестовые примеры.Идея состоит в том, чтобы убедиться, что тест действительно работает и может выявить ошибку.Как только это будет показано, начнется обычный цикл.Это была придумана "Мантра разработки, основанная на тестировании", известная как красный / зеленый / рефакторинг, где красный означает сбой, а зеленый - прохождение.Разработка, основанная на тестировании, постоянно повторяет этапы добавления тестовых примеров, которые завершаются неудачей, их прохождения и рефакторинга.Получение ожидаемых результатов тестирования на каждом этапе укрепляет ментальную модель кода программиста, повышает уверенность и повышает производительность

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

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

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

Лично я обнаружил, что парное программирование лучше всего работает с одним опытным и одним неопытным.

Т. е. я бы стремился к разнице в навыках / опыте программистов, а не пытался бы соответствовать одинаково квалифицированным.

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

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

Модульные тесты очень важны , imo ...в конце концов, некоторых сотрудников там не будет через 2 года.Как вы можете изменить существующий код, если нет ничего, с чем можно было бы сверить его функцию?

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

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

Хотя одна практика не требует другой, существует "хитрый" способ вводить и то, и другое понемногу за раз.

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

После пары дней с Шоном повторите со Сьюзен...

Сделай это в любом случае.Если менеджер поймает вас на сопряжении, произнесите волшебные слова "Проверка кода".
Предположение:Очевидно, что пара должна быть достаточно дисциплинированной / сфокусированной и выдавать рабочий код в конце сеанса

Напишите несколько тестов, которые привлекут внимание к существующим ошибкам в базе кода - затем покажите их своему боссу, я думаю, он может внезапно согласиться, что TDD - хорошая идея!

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top