Практика экстремального программирования

редактировать

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

Содержание
  • 1 Тонкая обратная связь
    • 1.1 Парное программирование
    • 1.2 Планирование игра
      • 1.2.1 Планирование выпуска
        • 1.2.1.1 Этап исследования
        • 1.2.1.2 Этап принятия обязательств
          • 1.2.1.2.1 Сортировать по значению
          • 1.2.1.2.2 Сортировать по риску
        • 1.2.1.3 Фаза управления
      • 1.2.2 Планирование итераций
        • 1.2.2.1 Этап исследования
        • 1.2.2.2 Фаза принятия обязательств
        • 1.2.2.3 Фаза управления
    • 1.3 Разработка через тестирование
    • 1.4 Вся команда
  • 2 Непрерывный процесс
    • 2.1 Непрерывная интеграция
    • 2.2 Улучшение дизайна
    • 2.3 Небольшие версии
  • 3 Общее понимание
    • 3.1 Стандарт кодирования
    • 3.2 Коллективное владение кодом
    • 3.3 Простой дизайн
    • 3.4 Системная метафора
  • 4 Благополучие программиста
    • 4.1 Устойчивый темп
  • 5 См. Также
  • 6 Ссылки
  • 7 Внешние ссылки
Точная обратная связь

Парное программирование

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

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

Игра в планирование

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

  • Планирование релизов: оно направлено на определение того, какие требования включены в какие краткосрочные релизы и когда они должны быть выполнены. И заказчики, и разработчики являются частью этого. Планирование выпуска состоит из трех этапов:
    • Этап исследования: на этом этапе заказчик предоставляет краткий список важных требований к системе. Они будут записаны на карточках пользовательских историй.
    • Фаза принятия обязательств: в рамках фазы принятия обязательств бизнес и разработчики обязуются использовать функциональные возможности, которые будут включены, и указать дату следующего выпуска.
    • Этап управления: на этапе управления план может быть скорректирован, могут быть добавлены новые требования и / или существующие требования могут быть изменены или удалены.
  • Планирование итераций: Планирует действия и задачи разработчиков. Заказчик в этом процессе не участвует. Планирование итераций также состоит из трех этапов:
    • Этап исследования: на этом этапе требования будут переведены на различные задачи. Задачи записываются на карточках задач.
    • Фаза приверженности: задачи будут назначены программистам, и время, необходимое для их выполнения, будет оценено.
    • Этап управления: задачи выполнены и конечный результат совпадает с исходной историей пользователя.

Цель игры в планирование - привести продукт к доставке. Вместо того, чтобы предсказывать точные даты, когда результаты будут необходимы и произведены, что сложно сделать, он стремится «направить проект» к реализации, используя простой подход. Подход «Игра в планирование» также был принят непрограммными проектами и командами в контексте гибкости бизнеса.

Планирование выпуска

фазы исследования

Это итеративный процесс сбора требований и оценка влияния каждого из этих требований на работу.

  • Напишите историю: у бизнеса возникла проблема; во время встречи разработчик попытается определить эту проблему и получить требования. На основе бизнес-задачи должна быть написана история (пользовательская история ). Это делается бизнесом, когда они указывают, что они хотят от части системы. Важно, что развитие никак не повлияет на эту историю. История написана на карточке пользовательской истории.
  • Оценить историю: разработка оценивает, сколько времени потребуется для выполнения работы, подразумеваемой карточкой истории. Разработка также может создавать пиковые решения для анализа или решения проблемы. Эти решения используются для оценки и отбрасываются, когда каждый получает четкое представление о проблеме. Опять же, это может не повлиять на бизнес-требования.
  • Разделите историю: каждая критическая сложность проекта должна быть рассмотрена до начала планирования итераций. Если разработчик не может оценить историю, ее нужно разделить и написать заново.

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

Этап принятия обязательств

Этот этап включает определение затрат, выгод и влияния на график. Он состоит из четырех компонентов:

  • Сортировать по значению: бизнес сортирует пользовательские истории по бизнес-ценности.
  • Сортировка по риску: разработка сортирует истории по риску.
  • Установить скорость: разработка определяет, на каком уровне скорость, с которой они могут выполнить проект.
  • Выберите объем: будут выбраны пользовательские истории, которые будут завершены в следующем выпуске. Дата выпуска определяется на основе пользовательских историй.
Сортировать по значению

Деловая сторона сортирует пользовательские истории по бизнес-ценности. Они сгруппируют их в три стопки:

  • Критические: истории, без которых система не может функционировать или не имеет смысла.
  • Значимые Бизнес-ценность : Некритические пользовательские истории, имеющие важное значение для бизнеса. значение.
  • Приятно иметь: пользовательские истории, не имеющие особой ценности для бизнеса.
Сортировать по риску

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

  • Определение индекса риска: дайте каждой пользовательской истории индекс от 0 до 2 по каждому из следующих факторов:
    • Полнота (знаем ли мы всю историю подробности?)
      • Завершено (0)
      • Неполно (1)
      • Неизвестно (2)
    • Волатильность (вероятно, изменится?)
      • низкий (0)
      • средний (1)
      • высокий (2)
    • Сложность (насколько сложно построить?)
      • простой (0)
      • стандартный (1)
      • сложный (2)

Все индексы для пользовательской истории добавляются, присваивая пользовательским историям индекс риска низкий (0–1), средний (2–4) или высокий (5–6).

Этап управления

На этапе управления программисты и бизнесмены могут «управлять» процессом. То есть они могут вносить изменения. Индивидуальные пользовательские истории или относительные приоритеты разных пользовательских историй могут измениться; оценки могут оказаться неверными. Это шанс соответствующим образом скорректировать план.

Планирование итераций

С учетом того, что нужно запланировать точки рассказа о скорости команды. Продолжительность итерации может составлять от 1 до 3 недель.

Этап исследования

Этап исследования итерационного планирования заключается в создании задач и оценке времени их выполнения.

  • Преобразуйте требование в задачи: поместите на карточках задач.
  • Задача объединения / разделения: если программист не может оценить задачу, потому что она слишком мала или слишком велика, программист должен будет объединить или разделить задача.
  • Оценить задачу: Оценить время, необходимое для реализации задачи.
Фаза принятия обязательств

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

  • Программист принимает задачу: каждый программист выбирает задачу, за которую он или она берет на себя ответственность.
  • Программист оценивает задачу: поскольку программист теперь отвечает за задачу, он или она должны дать конечную оценка задачи.
  • Установить коэффициент загрузки: коэффициент загрузки представляет собой идеальное время практической разработки на одного программиста в пределах одной итерации. Например, в 40-часовой рабочей неделе, когда 5 часов посвящены совещаниям, это будет не более 35 часов.
  • Балансировка: когда всем программистам в команде были назначены задачи, проводится сравнение между расчетное время выполнения задач и коэффициент загрузки. Затем задачи распределяются между программистами. Если программист перегружен, другие программисты должны взять на себя некоторые из его или ее задач, и наоборот.
Фаза управления

Реализация задач выполняется во время фазы управления итерацией.

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

Разработка через тестирование

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

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

  • Напишите модульный тест : программисты пишут минимальный тест, который должен завершиться неудачно, потому что функциональность не была полностью реализована в производственном коде.
  • Наблюдайте за тем, как новый тест не прошел: программисты убедитесь, что тест действительно не прошел. Хотя это может показаться пустой тратой времени, этот шаг имеет решающее значение, поскольку он подтверждает правильность вашего мнения о состоянии производственного кода. Если тест не завершился ошибкой, программисты должны определить, есть ли ошибка в тестовом коде или что производственный код поддерживает функциональность, описанную в новом тесте.
  • Написать код: программисты пишут ровно столько, сколько нужно. производственный код, чтобы новый тест прошел.
  • Выполнить тест: Модульные тесты выполняются для проверки того, что новый производственный код проходит новый тест и что все другие тесты не завершаются неудачно.
  • Рефакторинг : Удалите любой запах кода как из производственного, так и из тестового кода.

Для более интенсивной версии вышеуказанного процесса см. Три правила TDD дяди Боба.

Вся команда

В XP «покупатель» - это не тот, кто оплачивает счет, а тот, кто действительно использует систему. XP говорит, что заказчик должен быть всегда рядом и доступен для вопросов. Например, команда, разрабатывающая систему финансового администрирования, должна включать финансового администратора.

Непрерывный процесс

Непрерывная интеграция

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

Улучшение дизайна

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

Небольшие выпуски

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

Общее понимание

Стандарт кодирования

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

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

Коллективное владение кодом

Коллективное владение кодом (также известное как "командный код владение "и" общий код ") означает, что каждый несет ответственность за весь код; поэтому каждый может изменить любую часть кода. Коллективное владение кодом - это не только политика организации, но и чувство. «Разработчики больше ощущают владение кодом команды, когда они понимают контекст системы, внесли свой вклад в рассматриваемый код, воспринимают качество кода как высокое, верят, что продукт удовлетворит потребности пользователей, и ощущают высокую сплоченность команды». Парное программирование, особенно чередование пар с перекрытием, способствует этой практике: работая в разных парах, программисты лучше понимают контекст системы и вносят свой вклад в большее количество областей кодовой базы.

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

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

Простой дизайн

Программисты должны придерживаться подхода «простое лучше всего» к разработке программного обеспечения. Каждый раз, когда пишется новый фрагмент кода, автор должен спрашивать себя: «Есть ли более простой способ реализовать ту же функциональность?». Если "да", следует выбрать более простой курс. Для упрощения сложного кода также следует использовать рефакторинг.

Системная метафора

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

Благополучие программистов

Устойчивый темп

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

Кроме того, в эту концепцию входит то, что люди работают лучше и креативнее, если они хорошо отдохнули.

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

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

См. Также
Ссылки
Внешние ссылки
Последняя правка сделана 2021-05-19 10:22:38
Содержание доступно по лицензии CC BY-SA 3.0 (если не указано иное).
Обратная связь: support@alphapedia.ru
Соглашение
О проекте