У меня смешанные чувства о TDD. Хотя я верю в тестирование, у меня есть проблемы с идеей теста, который стимулирует мои усилия в области развития.
Когда вы выполняете код для удовлетворения некоторых тестов, написанных для интерфейса для требований, которые у вас есть прямо сейчас, вы можете перенести свой фокус с создания поддерживаемого кода, от чистого дизайна и от звуковой архитектуры.
У меня проблема с ведомым не с тестированием. Любые мысли?
Нет.
Если все сделано правильно, Test Driven Development - ваш инструмент разработки.
Надеюсь, вы простите меня за ссылку на мою собственную запись в блоге, в которой я обсуждаю подводные камни Test Driven Development, которые поступили не так, просто потому, что разработчики рассматривали свои тесты как просто тесты.
В предыдущем проекте разработчики использовали сильно повреждающий одноэлементный шаблон, в котором выполнялись зависимости во всем проекте, что просто нарушило все, когда были изменены требования:
TDD рассматривалась как задача, когда она следует рассматривать как подход. [...]
Не удалось распознать что TDD не касается тестов, о дизайне. Необузданный случай Singleton злоупотребления в единичных тестах это очевидно: вместо теста писатели, думающие "WTF - эти singleton = value; заявления, сделанные в мои тесты?", сценаристы просто распространил синглтон в тесты. 330 раз.
Несчастное последствие тестирование на основе сервера сборки чтобы пройти, что бы это ни потребовалось.
Test Driven Development, сделанный правильно, должен сделать разработчиков очень осведомленными о конструктивных ловушках, таких как жесткая связь, нарушения DRY (не повторяйте себя), нарушения SRP (принцип единой ответственности) и т.д.
Если вы пишете код для своих тестов для прохождения тестов, вы уже потерпели неудачу: вам следует тяжело писать тесты в качестве указателей, которые заставляют вас спросить: почему так делается? Почему я не могу проверить этот код без какого-либо другого кода? Почему я не могу повторно использовать этот код? Почему этот код нарушается, когда он используется сам по себе?
Кроме того, если ваш дизайн действительно чист, а ваш код по-настоящему поддерживается, почему нет тривиального написания теста для него?
Всегда существует риск переусердствовать либо с дизайном TDD, либо с предварительным дизайном. Поэтому ответ заключается в том, что это зависит. Я предпочитаю начинать с опроса пользователя/приемочного теста, который является основой требования, которое мои тесты помогут в производстве. Только после того, как я это установил, я начинаю писать подробные модульные тесты TDD-стиля. Если только дизайн и мышление вы делаете через TDD, тогда вы рискуете слишком большим подходом вверх, что может дать вам единицы и классы, которые отлично изолированы, но когда вы пытаетесь интегрировать их в задачу пользователя, выполняющую задачу, вы может быть удивлен, сделав все это неправильно. Для большего вдохновения, посмотрите att BDD.
Великая дискуссия об этом была зафиксирована между Робертом К. Мартином и Джеймсом Коплиеном, где первый является сторонником TDD и последний заявил, что он разрушает дизайн системы. Это то, что Роберт сказал о TDD и дизайне:
"В Agile появилось чувство сообщества примерно с '99, что архитектура не имеет значения, мы не нужно сделать архитектуру, все, что нам нужно сделать, это написать много тестов и сделать много историй и быстро итерации и код будут собраны сама по волшебству, и это всегда было лошадиным дерьмом. Я даже думаю, что большинство оригинальные сторонники Agile согласитесь, что это глупость".
Джеймс Коплиен утверждает, что просто управлять вашим дизайном от TDD имеет большой риск:
"Одна из вещей, которые мы видим много, в много проектов, заключается в том, что проекты идут на юг по поводу их третьего спринта и они падают и горят, потому что они не могут идти дальше, потому что они загнались в угол архитектурно. И вы не можете отредактируйте свой путь из этого, потому что рефакторинг должен проходить через класс категорий, в иерархиях классов, и вы больше не можете заверения в том, что функциональность".
Также он дает отличный пример того, как банковский счет, вероятно, будет выглядеть, если вы проверите его, по сравнению с использованием ваших предварительных знаний для управления архитектурой:
"Я помню, когда я разговаривал с Кент однажды, примерно в первые дни когда он предлагал TDD, и это был в смысле YAGNI и делал простейшая вещь, которая могла бы и он говорит:" Хорошо. Пусть сделают банковский счет, сберегательный счет ". Какой сберегательный счет? Это номер и вы можете добавить к номеру и вы можете вычесть из числа. Итак, что такое сберегательная учетная запись, является калькулятор. Позвольте сделать калькулятор, и мы можем показать, что вы можете добавить к баланс и вычесть из баланс. Это самая простая вещь что могло бы работать, все иначе это эволюция этого.
Если вы делаете реальную банковскую систему, сберегательный счет не является даже объектом и вы не собираетесь реорганизовывать свои путь к правильной архитектуре из вон тот. Что такое сберегательный счет, это процесс, который выполняет итерацию над аудиторским следом базы данных сделки, депозиты и проценты сборов и других Деньги. Это не похоже на сбережения счет - это деньги, сидящие на где-то на банке, хотя это перспектива пользователя и вы только что узнали, что есть эти относительно сложные структуры в основе банковской системы для поддержки налоговых лиц и актуариев и всех этих других людей, что вы не можете попасть в инкрементным способом. Ну, вы можете, потому что, конечно, банковская индустрия пришел к этому через 40 лет. Вы хотите дать себе 40 лет? Это не подвижный".
Интересно, что и сторонник TDD, и антагонист TDD говорят, что вам нужен дизайн спереди.
Если у вас есть время, посмотрите видео. Это отличная дискуссия между двумя очень влиятельными экспертами, и это всего лишь 22 минуты.
Я полностью согласен с pjz. Существует не один правильный способ разработки программного обеспечения. Если вы примите TDD до крайности, без какой-либо предусмотрительности, кроме следующей unit test, вы можете усложнить себе. То же самое для человека, который отправляется на грандиозный проект программного обеспечения, проводя месяцы на диаграммах и документации, но не с кодом.
Умеренный. Если вы чувствуете желание составить краткую диаграмму, которая поможет вам визуализировать структуру вашего кода, пойдите для этого. Если вам нужны две страницы, возможно, пришло время начать писать код. И если вы хотите это сделать, прежде чем писать свои тесты, то что. Целью является работа, качественное программное обеспечение, а не абсолютное соответствие какой-либо конкретной доктрине разработки программного обеспечения. Делайте то, что работает для вас и вашей команды. Найдите области, где могут быть сделаны улучшения. Итерация.
Я полностью согласен с вами в этом вопросе. На практике я думаю, что TDD часто имеет некоторые очень негативные последствия для базы кода (дерьмовый дизайн, процедурный код, отсутствие инкапсуляции, производственный код, замусоренный тестовым кодом, интерфейсы повсюду, сложный для кода рефакторинга, потому что все тесно связано со многими тестами и т.д.).
Джим Коплиен уже некоторое время беседует по этой теме:
Недавние исследования (Siniaalto and Абрахамссон) TDD показывают, что он может не имеют преимуществ по сравнению с традиционными последняя разработка и что в некоторых случаи ухудшили код и что у него есть другие тревожные (их слова). Меня волнует самое главное, что это ухудшает архитектура. - Jim blog
Существует также обсуждение в InfoQ между Робертом К. Мартином и Джеймсом Коплиеном, где они затрагивают эту тему.
Мой способ подумать над этим, написать то, что вы хотите, чтобы ваш код выглядел первым. Если у вас есть образец целевого кода (который сейчас ничего не делает), посмотрите, можете ли вы разместить на нем тестовые леса. Если вы не можете этого сделать, выясните, почему вы не можете. В большинстве случаев это вызвало плохое дизайнерское решение (99%), однако если это не так (1%), попробуйте следующее:
После того, как у вас есть целевой код и тестовые леса. Внедрите код. Теперь у вас даже есть преимущество, зная, насколько хорошо вы прогрессируете, когда вы проходите собственный тест (его отличный мотиватор!)
Единственный случай, когда тестирование может быть излишним, из личного опыта, - это когда вы делаете ранний прототип, потому что в этот момент вы все еще недостаточно понимаете проблему достаточно, чтобы правильно спроектировать или проверить ваш код.
Для завершения программного обеспечения существует три шага:
Тесты дают вам №1. Ваш код не выполняется только потому, что тесты прошли. Прежде чем приступать к написанию своих тестов/кода, у вас есть концепция концепции проекта (Утилиты, общедоступные объекты, слои, рамки). После того, как вы написали свой код, чтобы пройти тесты, вам нужно переоценить его, чтобы посмотреть, какие части могут быть реорганизованы в различные аспекты вашего приложения. Yuo может сделать это уверенно, потому что вы знаете, что пока ваши тесты все еще проходят, ваш код по-прежнему функционирует (или, по крайней мере, соответствует требованиям).
В начале проекта подумайте о структуре. По мере продолжения проекта продолжайте оценивать и переоценивать свой код, чтобы сохранить дизайн на месте или изменить дизайн, если он перестает иметь смысл. Все эти элементы должны учитываться при оценке, или вы получите код спагетти, TDD или нет.
Это всегда баланс:
- слишком много TDD, и вы получаете код, который работает, но это боль для работы.
- слишком много "основного кода", чистого дизайна и звуковой архитектуры ", и вы получаете Архитектура астронавтов, которые говорили о парадизе кодирования
Умеренность во всех вещах.
Я относительно новичок в TDD и модульном тестировании, но в двух боковых проектах, которые я использовал, я нашел его помощником по дизайну, а не альтернативой дизайну. Умение тестировать и проверять компоненты/подкомпоненты самостоятельно облегчило мне быстрые изменения и опробовать новые дизайнерские идеи.
Разница, с которой я столкнулась с TDD, - надежность. Процесс разработки компонентного взаимодействия на меньших уровнях компонента в начале процесса проектирования, а не позже, заключается в том, что у меня есть компоненты, которым я могу доверять, будет работать раньше, поэтому я могу перестать беспокоиться о маленьких кусочках и вместо этого получить для решения сложных проблем.
И когда мне неизбежно нужно вернуться и сохранить маленькие кусочки, я могу потратить меньше времени на это, поэтому я могу вернуться к работе, которую я хочу делать.
По большей части я согласен с тем, что TDD предоставляет своего рода инструмент проектирования. Самая важная часть этого для меня - это способ, которым она строится в способности делать больше изменений (вы знаете, когда у вас есть эта вспышка проницательности, где вы можете добавить функциональность, удалив код) со значительно сниженным риском.
Тем не менее, некоторые из более алгоритмических работ, с которыми я заключил контракт, в последнее время немного пострадали от TDD без тщательного баланса дизайнерской мысли. Вышеприведенное утверждение о более безопасном рефакторинге по-прежнему было большой выгодой, но для некоторых алгоритмов TDD (хотя и полезен) недостаточно для того, чтобы вы могли достичь идеального решения. Возьмите сортировку как простой пример. TDD может легко привести вас к субоптимальному (N ^ 2) алгоритму (и scads прохождения тестов, которые позволяют вам реорганизовать быстрый сортировку), как сортировка пузырьков. TDD - это инструмент, очень хороший инструмент, но, как и многие вещи, необходимо использовать соответствующим образом для контекста решаемой проблемы.
Здесь много неофициальных мнений, в том числе популярное мнение (от Джона Лимьяпа) о том, что плохие результаты приходят от неправильного действия, и утверждает, что они кажутся неподдерживаемыми не более чем личным опытом. Экспериментальные доказательства преобладания и опубликованные результаты указывают в противоположном направлении от этого опыта.
Теория заключается в том, что метод, который требует от вас писать тесты перед кодом, приведет к мысли о дизайне на уровне отдельных фрагментов кода, т.е. в программировании в малом. Поскольку процедуры - все, что вы можете проверить (вы все еще проверяете объект по одному методу за раз, и вы просто не можете тестировать классы на большинстве языков), ваш фокус дизайна зависит от индивидуальных методов и того, как они составлены. Это теоретически приводит к процедуре снизу вверх и, в свою очередь, к плохому сцеплению и сплоченности между объектами.
Широкие эмпирические данные подтверждают теорию. Siniaalto и Abrahamsson (Сравнительный пример влияния развития, основанного на испытаниях на разработку и тестирование программ), ESEM 2007, показали, что "наши результаты показывают, что когезия может быть хуже (хотя Бек утверждает, что TDD создает сильно когезионные системы). В нашем втором исследовании мы заметили, что меры сложности были лучше с TDD, но показатели управления зависимостями были явно хуже". Janzen и Saledian (имеет ли развитие, основанное на тестах, действительно улучшить качество разработки программного обеспечения?). IEEE Software 25 (2), март/апрель 2008 г., стр. 77 - 84) обнаружил, что "результаты [T] не подтверждают утверждения о более низкой связи и усиление сцепления с TDD".
В обзоре литературы будут раскрыты другие публикации, посвященные этим случаям.
Даже мой дорогой друг дядя Боб пишет: "Один из наиболее коварных и упорных мифов о гибком развитии - это то, что архитектура и дизайн на переднем плане плохие, и вам никогда не стоит тратить время на принятие архитектурных решений. не измените свою архитектуру и дизайн из ничего, по одному тестовому корпусу за раз. Простите меня, но это Horse Shit. (" Скатология гибкой архитектуры", http://blog.objectmentor.com/articles/2009/04/25/the-scatology-of-agile-architecture)
Однако, стоит отметить, что более широкий отказ состоит в том, что люди считают это методикой тестирования, а не техникой проектирования. Ошеров указывает на множество подходов, которые часто случайно приравниваются к TDD. Я не могу быть уверен в том, что подразумевалось под этими плакатами. См. http://weblogs.asp.net/rosherove/archive/2007/10/08/the-various-meanings-of-tdd.aspx.