Экстремальное программирование - методология XP. В проекте, который работает по методологии XP процесс построен таким образом. Обратная связь в XP реализуется сразу в трех направлениях

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

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

• общение;
• простота;
• обратная связь;
• храбрость.

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

• Игра в планирование;
• Тестирование до начала разработки;
• Парное программирование;
• Постоянная переработка;
• Простота разработки;
• Коллективное владение кодом;
• Продолжающаяся интеграция;
• Заказчик на рабочей площадке;
• Быстрый выпуск версий;
• Сорокачасовая рабочая неделя;
• Стандарты кодирования;
• Метафора системы.

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

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

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

Метафора системы. Разрабатываемые продукты или фрагменты кода сравниваются, с
какими-либо аналогичными продуктами или явлениями. Строятся метафоры. Это
упрощает понимание задачи, а, соответственно, ускоряет разработку.

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

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

Теперь давайте посмотрим, как подходы ХР могут быть использованы на практике в
наших условиях. Одной из моих на работе задач является автоматизация учебного
процесса. Собственно говоря, я на протяжении достаточно большого отрезка времени
занимаюсь написанием приложения, осуществляющего (по крайней мере по замыслу
автора:)) комплексное решение этой проблемы. Бюджет у проекта мизерный, а объем
работ – приличный. Еще одним, чуть ли не решающим фактором было постоянное
видоизменение предметной области. Регулярно меняются формы отчетной
документации, и методика их получения. Сложилась ситуация, когда проект перестал
успевать за требованиями пользователя. И однажды наступил момент, когда в силу
объективных и субъективных причин, разработку можно было смело хоронить. Однако
неожиданно передо мной была поставлена конкретная задача определения
загруженности аудиторного фонда на семестр. К этому моменту из трех участников
проекта остался я один, а данная подсистема не была реализована и реализация ее
даже не стояла в ближайших планах развития проекта. О таких мелочах как
грамотная постановка задачи, подсчет трудоемкости работ, выделении
дополнительных ресурсов никто даже и не задумался. На выполнение задачи было
отведено две недели. При этом мои аргументы, касающиеся невозможности выполнения
данной задачи не рассматривались в принципе. Первым моим решением было подыскать
себе другого работодателя, так как за две недели я был должен написать не только
модуль анализа загруженности аудиторного фонда, но и систему ввода расписания
занятий, контроля накладок и многое другое. Автономно, данная задача не решается
в принципе — нужны исходные данные. И не просто исходные данные, а корректные
исходные данные, откуда и вытекают все вышеперечисленные задачи. Тем не менее,
не знаю почему, но я взялся за решение этой задачи.

Естественно, что говорить о разработке классическими методами в данном случае
неуместно. Вот здесь-то и пригодились подходы ХР. Общее представление о задаче я
уже имел, однако имелось множество нюансов, которые потенциально могли
значительно увеличить объем работ. Начал работу я с того, что набрал номер
учебного отдела и стал засыпать снявшего трубку массой вопросов, ответы на
которые я не мог найти самостоятельно или в которых я не был уверен.
.
Я запустил Rational Rose и приступил к составлению модели. К концу рабочего дня
я набросал модель, показавшуюся мне более-менее адекватной. После работы я
предпринял еще один шаг, отвечающий идеологии ХР. Я вытащил своего приятеля,
работающего в учебном отделе попить пива. В процессе этого, важного во всех
отношениях мероприятия, я изложил ему свое виденье программы, ее интерфейса и
логики работы. Он, в свою очередь, принимался рассказывать о необходимости
решения некоторых локальных подзадач. К вечеру я уже более четко уяснил, что же
все-таки нужно сделать в рамках данного проекта (я уже не сомневался, что задачу
следует рассматривать как отдельный проект). Тем не менее, не был решен еще один
не маловажный вопрос – выбор средств разработки. Когда происходили описываемые
события, я начинал активно изучать MDA технологию. Вкратце, суть ее такова:
фрагменты кода приложения и структуры данных генерируются автоматически, исходя
из UML модели, что позволяет существенно сократить время разработки. В рамках
данной статьи я не буду детально описывать принципы работы MDA, но хочу
акцентировать ваше внимание на том, что использование этой технологии полностью
отвечает «духу XP». Связано это с тем, что одним из условий, при котором
методики XP будут успешно работать, это снижение стоимости изменений, вносимых в
приложение на поздних стадиях разработки. Среди факторов, способствующих
достижению этого, не маловажным является использование различных новых
технологий программирования. Замечу, что именно простота рефакторинга MDA
приложений является одним из основных преимуществ этой технологии. Вообще, на
сегодня существует достаточно много реализаций MDA, я остановил свой выбор на
Bold for Delphi.

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

Альтернативным вариантом было написание «обычного» Delphi приложения. Я запустил
ICQ и написал сообщение своему знакомому – адепту Bold. После того, как я
вкратце изложил ему суть проблемы, я спросил, как бы он на моем месте поступил.
Он ответил примерно следующим образом: «Либо погружаться с головой в Bold, либо
ты никогда не освоишь его. Сделать серьезный проект – лучший способ изучить
технологию». Собственно, другого ответа я и не ожидал.

С утра я взял существующую модель и начал строить приложение. Именно, строить. К
кодированию я не приступал, а просто набросал пользовательский интерфейс, многие
элементы которого практически сразу заработали. На перекур я старался выходить в
компании сотрудников учебного отдела, это позволяло мне затащить очередную
«жертву» к экрану своего монитора и (не без некоторой доли гордости) показывал
промежуточные результаты. Таким образом, реализовывался принцип обратной связи.
Вы можете справедливо заметить: «А как же парное программирование?». Да,
действительно, в качестве программиста в проекте участвовал я один. Но тут я
упомяну еще об одном счастливом стечении обстоятельств. В тот период времени,
когда происходили описываемые события, я, совместно с группой разработчиков —
энтузиастов развивал Интернет-проект, посвященный, именно MDA. И вот, когда я
подошел к самому сложному месту в своей разработке, этот проект принес
совершенно неожиданные результаты.

В течение нескольких дней я писал код процедуры, реализующей отображение занятий
на экране. Стандартные элементы управления не позволяли вывести на экран все
данные, в той форме, в которой они обычно представляются. Мне же хотелось, что
бы конечный пользователь хотя бы приблизительно понимал, что же делает программа
и как с ней работать. Я написал свой компонент, на основе обычного TStringGrid.
Я не был уверен в том, что это было хорошее решение, но код работал. В форуме
нашего проекта я изложил свое решение, ожидая получить какую-то оценку в течение
достаточно долгого промежутка времени. Однако буквально через 15-20 минут пришел
первый ответ. Предлагался альтернативный вариант решения, а еще через 10 минут
пришел тестовый пример, да не один, а сразу два, от двух авторов. Если
задуматься над тем, почему разработчики, с таким энтузиазмом принялись решать
чужую задачу, то можно прийти к простому выводу. Во-первых, им просто было
интересно найти некоторое универсальное решение, которое затем можно
использовать в своих проектах. А во-вторых, им был интересен сам процесс
общения. Надо отметить, что с таким же энтузиазмом решались и другие задачи
различного уровня сложности. Конечно, это не является парным программированием в
обычном понимании. Скорее это некий суррогат, но, тем не менее, в этом есть и
свои плюсы. Скажем, все высказываемые мысли, и идеи автоматически
документировались, и к ним можно было обратиться в любой момент.

На тестах я хотел бы остановиться отдельно. Как рекомендует в своей книге
«Экстремальное программирование» Кент Бек, тесты должны писаться заранее. Более
того, у автора это выглядит примерно так. Имеется специальная программа,
написанная самим разработчиком, при нажатии на одну из кнопок которой
запускаются все тесты, а в итоге на экране появляется зеленая «лампочка» в
случае позитивного результата и красная в противном случае. Меня такое описание
несколько обескуражило. Согласитесь, сложно себе представить, каким образом
можно написать программу, имитирующую действия пользователя, абсолютно во всех
ситуациях.

Как я уже говорил, я не старался строго придерживаться методик экстремального
программирования. А в прочитанных мною книгах недвусмысленно утверждалось, что
написание теста – один из наиболее важных моментов в XP, и без этого остальные
методики сработать не должны. Почему же в итоге я достиг положительного
результата? Все оказалось достаточно просто. Ответить на этот вопрос мне помог
именно этот пример с зелеными и красными лампочками. Дело в том, что в Bold
имеется возможность показать, соответствует – ли данный объект модели. И
делается это как раз с помощью подобных «лампочек». Буквально две строки,
которые я почти сразу вставил в код приложения, позволяли мне увидеть, в каком
месте происходит несоответствие (если таковое имеется). Именно это и заменило
мне тестирование. Возможно, что такой подход и не совсем соответствовал
оригинальной идее «тестирования до начала разработки», но это сработало.

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

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

http://xprogramming.com.ua/ — мир
экстремального программирования

http://www.xprogramming.ru/ —
экстремальное программирование по русски

http://www.maxkir.com/ — о разработке
программного обеспечения

http://xprogramming.com/ — сайт
идеолога XP Рона Джеффриса

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

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

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

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

В основе экстремального программирования лежат не конкретные методики, как принято считать, а лишь четыре базовых принципа: общение, простота, обратная связь и храбрость. Именно с них необходимо начинать.

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

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

Экстремальный цикл

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

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

Как следствие постоянно изменяющихся требований следует другой принцип - позднее принятие решений.

Submitted by on Wed, 01/25/2012 - 02:28

7. Адаптивные модели процесса разработки: , Scrum

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

Адаптивные процессы делают упор на использовании хороших разработчиков, а не хорошо отлаженных процессов разработки
Они избегают фиксации четких схем действий , чтобы обеспечить большую гибкость в каждом конкретном проекте и не требуют разработки дополнительных промежуточных документов

Принципы «живой» разработки

Основные принципы «живой» разработки ПО зафиксированы в манифесте, появившемся в 2000 году:=

1. Люди, участвующие в проекте, и их общение более важны, чем процессы и инструменты
2. Работающая программа более важна, чем исчерпывающая документация
3. Сотрудничество с заказчиком более важно, чем обсуждение деталей контракта
4. Отработка изменений более важна, чем следование планам

Экстремальное программирование

Наиболее часто используемой адаптивной моделью является модель экстремального программирования (eXtreme Programming, XP-процесс)
XP-процесс ориентирован на группы малого и среднего размера, разрабатывающих ПС в условиях неопределенных или быстро меняющихся требований

XP-процесс (экстремальное программирование)

Основная идея XP-процесса – устранить высокую стоимость внесения изменений . Это достигается путем резкого (до двух недель) сокращения длительности отдельных итераций .
Базовыми действиями xp являются:=

1. кодирование,
2. тестирование,
3. выслушивание заказчика,
4. проектирование

Принципы XP

Высокий динамизм разработки обеспечивается следующими принципами:=

1. непрерывная связь с заказчиком,
2. простота выбираемых решений,
3. быстрая обратная связь на основе оперативного тестирования,
4. профилактика рисков

Практики XP разработки

Реализация этих принципов достигается за счет использования следующих методов:=

1. Метафора – вся разработка ведется на основе простой, общедоступной истории о том, как работает система
2. Простое проектирование – принимаются наиболее простые из возможных проектные решения
3. Непрерывное тестирование как отдельных модулей, так и системы в целом; входным критерием для написания кода является отказавший тестовый вариант
4. Реорганизация (Refactoring) – улучшение структуры системы при сохранении ее поведения
5. Парное программировани е – код пишется двумя программистами на одном компьютере
6. Коллективное владение кодом – любой разработчик может улучшить код любого модуля системы
7. Непрерывная интеграция – система интегрируется как можно чаще ; непрерывное регрессионное тестирование гарантирует сохранение функциональности при изменении требований
8. Локальный заказчик – в группе все время должен находиться компетентный представитель заказчика
9. Стандарты кодирования – должны выдерживаться правила, обеспечивающие одинаковое представление кода во всех частях системы

схема XP разработки

изображение XP (схема XP разработки):

Scrum-модель

Является еще одним примером адаптивного процесса разработки (ранее мы рассматривали )
Основные идеи модели сформулировали Хиротака Такеути и Икудзиро Нонака в 1986 году

Основная идея Scrum-модели

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

Такеуки и Ноната объяснили это как «подход регби» и ввели и сам термин

«scrum» - «толкотня; схватка вокруг мяча (в регби)»

Впервые метод Scrum был представлен в документированном виде в 1996 году совместно Сазерлендом и Швабером

Роли

1. ScrumMaster , тот кто занимается процессами и работает в качестве руководителя проекта,
2. Владелец Продукта , человек, который представляет интересы конечных пользователей и других заинтересованных в продукте сторон,
3. Команда , которая включает разработчиков

Этапы разработки

Процесс разработки разбивается на отдельные этапы определенной длительности – спринты (обычно,15-30 дней)
Каждому спринту предшествует этап, который называется product backlog –документирование запросов на выполнение работ

Планирование спринта

Запросы на выполнение работ определяются на этапе совета по планированию спринта – sprint planning meeting

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

Выполнение спринта

Во время спринта команда выполняет определенный фиксированный список заданий - backlog items , наращивая функциональность программного продукта

На протяжении этого периода никто не имеет права менять список требований к работе , что следует понимать, как заморозку требований (requirements) во время спринта

Scrum схема =

текст опорного ответа (не позиционирую его как обязательное)

Экстремальное программирование

Основные приёмы XP

· Короткий цикл обратной связи (Fine scale feedback)

o Разработка через тестирование (Test driven development)

o Игра в планирование (Planning game)

o Заказчик всегда рядом (Whole team, Onsite customer)

o Парное программирование (Pair programming)

· Непрерывный, а не пакетный процесс

o Непрерывная интеграция (Continuous Integration)

o Рефакторинг (Design Improvement, Refactor)

o Частые небольшие релизы (Small Releases)

· Понимание, разделяемое всеми

o Простота (Simple design)

o Метафора системы (System metaphor)

o Коллективное владение кодом (Collective code ownership) или выбранными шаблонами проектирования (Collective patterns ownership)

o Стандарт кодирования (Coding standard or Coding conventions)

· Социальная защищенность программиста (Programmer welfare):

o 40-часовая рабочая неделя (Sustainable pace, Forty hour week)

Тестирование

В XP особое внимание уделяется двум разновидностям тестирования:

· тестирование модулей (unit testing);

· приемочное тестирование (acceptance testing).

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

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

Для XP более приоритетным является подход, называемый TDD (Test Driven Development) - сначала пишется тест, который не проходит, затем пишется код, чтобы тест прошел, а уже после делается рефакторинг кода.

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

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

Заказчик всегда рядом

«Заказчик» в XP - это не тот, кто оплачивает счета, а тот, кто на самом деле использует систему. XP утверждает, что заказчик должен быть всё время на связи и доступен для вопросов.

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

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

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

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

Рефакторинг

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

Частые небольшие релизы

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

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

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

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

Метафора системы

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

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

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

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

Все члены команды в ходе работы должны соблюдать требования общих стандартов кодирования. Благодаря этому:

· члены команды не тратят время на глупые споры о вещах, которые фактически никак не влияют на скорость работы над проектом;

· обеспечивается эффективное выполнение остальных практик.

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

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

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

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

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

Главные действующие роли в Scrum: ScrumMaster - тот, кто ведёт Scrum митинги и следит, чтобы при этом соблюдались все принципы Scrum (роль не предполагает ничего кроме корректного ведения самого Scrum-а, руководитель проекта скорее относится к Product Owner и не должен являться ScrumMaster); Владелец Продукта (Product Owner) - человек, который представляет интересы конечных пользователей и других заинтересованных в продукте сторон; и кросс-функциональная Команда (Scrum Team), состоящая как из разработчиков, так и из тестировщиков, архитекторов, аналитиков и т. д. (при этом размер команды в идеале составляет 7±2 человека). Команда является единственным полностью вовлечённым участником разработки, и отвечает за результат как единое целое. Никто кроме команды не может вмешиваться в процесс разработки на протяжении спринта.

На протяжении каждого спринта создаётся функциональный рост программного обеспечения. Набор возможностей, которые реализуются в каждом спринте, происходят из этапа, называемого product backlog (документация запросов на выполнение работ), обладающего наивысшим приоритетом по уровню требований к работе, который должен быть выполнен. Запросы на выполнение работ (backlog items), определенных на протяжении совета по планированию спринта (sprint planning meeting), перемещаются в этап спринта. На протяжении этого собрания Владелец Продукта информирует о заданиях, которые должны быть выполнены. Тогда Команда определяет, сколько из желаемого они могут выполнить, чтобы завершить необходимые части на протяжении следующего спринта. Во время спринта команда выполняет определенный фиксированный список заданий (т. н. sprint backlog). На протяжении этого периода никто не имеет права менять список требований к работе, что следует понимать как заморозку требований (requirements) во время спринта.

_____________
матфак вгу и остальная классика =)

• Log in to post comments

Экстремальное программирование или XP, eXtreme Programming — гибкая методология разработки программного обеспечения. Как и у других agile методологий, у нее есть особенные инструменты, процессы и роли. Хотя автор XP не придумал ничего нового, а взял лучшие практики гибкой разработки и усилил до максимума. Поэтому программирование и зовется экстремальным.

Автор методики — американский разработчик Кент Бек. В конце 90-х годов он руководил проектом Chrysler Comprehensive Compensation System и там впервые применил практики экстремального программирования. Свой опыт и созданную концепцию он описал в книге Extreme Programming Explained, опубликованной в 1999 году. За ней были выпущены другие книги, в которых подробно описывались практики XP. К становлению методологии причастны также Уорд Каннингем, Мартин Фаулер и другие.

XP отличается от других гибких методологий тем, что применимо только в области разработки программного обеспечения. Оно не может быть использовано в другом бизнесе или повседневной жизни, как scrum, kanban или lean.

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

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

1. Вся команда

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

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

Планирование в XP проводят в два этапа — планирование релиза и планирование итераций.

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

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

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

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

3. Частые релизы версий

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

4. Пользовательские тесты

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

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

В XP любой разработчик может править любой кусок кода, т.к. код не закреплен за своим автором. Кодом владеет вся команда.

6. Непрерывная интеграция кода

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

7. Стандарты кодирования

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

8. Метафора системы

Метафора системы — это ее сравнение с чем-то знакомым, чтобы сформировать у команды общее видение. Обычно метафору системы продумывает тот, кто разрабатывает архитектуру и представляет систему целиком.

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

XP команды работают на максимуме продуктивности, сохраняя устойчивый темп. При этом экстремальное программирование негативно относится к переработкам и пропагандирует 40-часовую рабочую неделю.

10. Разработка, основанная на тестировании

Одна из самых трудных практик методологии. В XP тесты пишутся самими программистами, причем ДО написания кода, который нужно протестировать. При таком подходе каждый кусок функционала будет покрыт тестами на 100%. Когда пара программистов заливают код в репозиторий, сразу запускаются модульные тесты. И ВСЕ они должны сработать. Тогда разработчики будут уверены, что движутся в правильном направлении.

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

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

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

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

13. Рефакторинг

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

Преимущества и недостатки XP

Методология XP вызывает много споров и критики со стороны тех, кто так и не смог ее внедрить в своей команде.

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

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

Несмотря на все плюсы, XP не всегда работает и имеет ряд слабых мест. Итак, экстремальное программирование — недостатки:

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

Принципы XP

В первой книге Кент Бек сформулировал такие принципы экстремального программирования: простота, коммуникация, обратная связь и смелость. В новом издании книги он добавил пятый принцип — уважение.

1. Простота

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

2. Коммуникация

В XP коммуникация между разработчиками ведется не посредством документации, а вживую. Команда активно общается между собой и с заказчиком.

3. Обратная связь

Обратная связь в XP реализуется сразу в трех направлениях:

1. фидбек от системы при постоянном тестировании модулей
2. фидбек от заказчика, т.к. он входит в команду и участвует в написании приемочных тестов
3. фидбек от команды во время планирования касательно времени на разработку.

4. Смелость

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

5. Уважение

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

Алгоритм внедрения методологии XP и процесс работы

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

Чтобы внедрить XP в существующий проект, нужно постепенно осваивать его методики в области:

• тестирования
• проектирования
• планирования
• менеджмента
• разработки

Тестирование.

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

Проектирование.

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

Планирование.

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

Менеджмент.

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

Разработка.

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

В проекте, который работает по методологии XP процесс построен таким образом:

Кто использует XP

По данным исследования Versionone за 2016 год всего 1% agile компаний используют экстремальное программирование в чистом виде. Еще 10% работают по гибридной методологии scrum и XP.

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

Не так просто найти информацию о командах, которые применяют XP, но есть и те, кто афиширует, что именно эта методология — причина их успеха. Пример экстремального программирования — компания Pivotal Software, Inc.

Pivotal Software, Inc.

Американская софтверная компания, которая разрабатывает ПО для бизнес-анализа на основе big data и оказывает консультационные услуги. Продуктами Pivotal пользуются корпорации Ford, Mercedes, BMW, GAP, Humana, крупные банки, государственные учреждения, страховые компании и т.д.

Pivotal — адвокат agile методологий, как единственно возможных в современной разработке. Из всех вариантов гибких методологий компания выбрала XP как win-win подход для заказчиков и команд программистов. Каждый рабочий день начинается с собрания на ходу, и заканчивается ровно в 18:00 — никаких переработок. Pivotal использует игру в планирование, парное программирование, постоянное тестирование, непрерывную интеграцию и другие практики XP. Для многих практик у них есть собственное ПО.

Экстремальное программирование,
Экстремальное программирование: планирование,
Экстремальное программирование: разработка через тестирование / Кент Бек

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

Рефакторинг: улучшение существующего кода / Мартин Фаулер

Экстремальное программирование: постановка процесса. С первых шагов и до победного конца / Кен Ауэр, Рой Миллер

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

Приложения для внедрения XP в команде

Команды, работающие над проектами по методологии XP, применяют таск менеджеры и сервисы для agile проектов. На рынке много таких продуктов, мы рассмотрим несколько примеров.

Бесплатный менеджер задач с открытым кодом. Основные функции: работа сразу над несколькими проектами, гибкая система управления задачами, диаграмма Ганта, контроль времени, работа с документацией, создание задач через почту и др.

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

Jira

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

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

Вердикт

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

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

Это одна из самых трудных для внедрения методологий, поскольку она включает целых тринадцать практик!

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

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

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

Ускоренная и совместная разработка приложений

ак правило, конечные пользователи и представители руководства компании-заказчика полагают, что процесс проектирования не увенчался успехом, если отсутствуют реальные готовые компоненты. Зачастую заказчик настаивает на досрочном проведении этапа реализации проекта, чтобы как можно быстрее получить конкретный результат и продемонстрировать его. В таком случае существует большой соблазн выбрать ускоренную разработку приложений (УРП) или совместную разработку приложений (СРП). Подобные методы предусматривают разработку рабочего прототипа с последующей демонстрацией его пользователям, которые отмечают, что им нравится, а что нет. После этого проектировщик дорабатывает прототип с учетом сделанных замечаний, а затем снова демонстрирует то, что получилось. Процесс повторяется до тех пор, пока пользователи не будут удовлетворены тем, что они видят, а прототип не станет рабочим приложением. Обычно устанавливаются лимит времени и количество итераций, ибо в противном случае пользователи будут бесконечно требовать новых совершенствований прототипа. Теоретически это позволяет получить именно ту систему, которая необходима пользователям.

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

На практике подобный подход к разработке приложений сопряжен с проблемами, перечисленными ниже:

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

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

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

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

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

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

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

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

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

Экстремальное программирование

Принципы XP и используемые методы ускорения разработки

Отцом-идеологом экстремального программирования считают Кента Бека (Kent Beck). XP является достаточно молодой методологией, оценки которой весьма противоречивы - от восторженных до резко негативных. Основными принципами являются:

Простота решений (simplicity).

Интенсивная разработка малыми группами (не больше 10 человек), активное общение в группе и между группами (communication).

Обратная связь с клиентом (feedback), который фактически вовлечен в процесс разработки.

Достаточная степень смелости (courage) и желание идти на риск.

Первый фактор ускорения разработки - итеративность: разработка ведется короткими итерациями при наличии активной взаимосвязи с заказчиком. XP - это итеративный процесс разработки, который сам по себе не является революционным. Итерации как таковые предлагается делать короткими, рекомендуемая длительность - 2-3 недели и не более 1 месяца. За одну итерацию группа программистов обязана реализовать несколько свойств системы, каждое из которых описывается в пользовательской истории (user story). Пользовательские истории в данном случае являются начальной информацией, на основании которой создается модуль. Пользовательские истории отличаются от прецедентов (use case): пользовательская история коротка - 1-2 абзаца, тогда как прецеденты обычно пишут достаточно подробными, с основным и альтернативными потоками - таким образом, получается примерно страница плюс схема (наиболее распространенная формализация в настоящее время предложена в UML); истории пользователей пишутся самими пользователями (которые в XP являются частью команды) в отличие от прецедентов, которые обычно пишет системный аналитик. Отсутствие формализации описания входных данных проекта в XP стремятся компенсировать посредством активного включения в процесс разработки заказчика как полноправного члена команды и за счет наличия постоянного контакта с заказчиком (активное общение и непрерывная поддержка обратной связи). В данном случае extreme - это степень привлечения заказчика к программистской кухне, что обусловлено стремлением сжать сроки разработки за счет коммуникации и обратной связи.

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

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

Практики

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

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

Тесное взаимодействие с заказчиком (feed-back, on-site customer). Заказчик должен быть членом XP-команды (on-site customer). Он пишет пользовательские истории, выбирает истории, которые будут реализованы в конкретной итерации, и отвечает на вопросы, касающиеся бизнеса. Заказчик должен быть экспертом в автоматизируемой предметной области. Необходимо постоянное наличие обратной связи с заказчиком (feed-back).

Метафора системы (system metaphor). Хорошая метафора системы означает простоту именования классов и переменных. В реальной жизни поиск метафоры - крайне сложное занятие; найти хорошую метафору непросто. В любом случае команда должна иметь единые правила именования.

Простая архитектура (simple design). Любое свойство системы должно быть реализовано как можно проще. Программисты в XP-команде работают под девизом: «Ничего лишнего!». Принимается первое наипростейшее работающее решение, реализуется необходимый уровень функциональности на данный момент. Тем самым экономится время программиста.

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

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

Парное программирование (pair programming) - одна из самых известных XP-практик. Все программисты должны работать в парах: один пишет код, другой смотрит. Таким образом, необходимо размещать группу программистов в одном месте, что легче всего сделать на территории заказчика (все необходимые члены команды географически находятся в одном месте); XP наиболее успешно работает в нераспределенных коллективах программистов и пользователей.

40-часовая рабочая неделя. Программист не должен работать более 8 часов в день. Необходимость сверхурочной работы (overtime) - это четкий индикатор проблемы на данном конкретном направлении разработки; к тому же заказчик не платит за сверхурочную работу в XP. Поиск причин сверхурочной работы и их скорейшее устранение - одно из основных правил.

Коллективное владение кодом (collective code ownership). Каждый программист в коллективе XP должен иметь доступ к коду любой части системы и вносить изменения в любой код. Обязательное правило: если программист внес изменения и система после этого работает некорректно, то именно этот программист должен исправить ошибки. В противном случае работа системы уподобится тотальному хаосу.

Частая смена версий (small releases). Минимальная итерация - один день, максимальная - месяц; чем чаще осуществляются релизы, тем больше недостатков системы будет выявлено. Первые релизы помогают выявить недостатки на самых ранних стадиях, далее функциональность системы расширяется (на основании тех же пользовательских историй). Поскольку пользователь включается в процесс разработки начиная с первого релиза, то он оценивает систему и выдает пользовательскую историю плюс feedback. На основании этого определяется следующая итерация: каким будет новый релиз. В XP все направлено на обеспечение непрерывной обратной связи с пользователями.

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

Тестирование (testing). В отличие от большинства остальных методологий тестирование в XP - одно из важнейших составляющих. Экстремальный подход заключается в том, что тесты пишутся до написания кода. Каждый модуль обязан иметь unit test - тест данного модуля; таким образом, в XP осуществляется regression testing (возвратное тестирование, «неухудшение качества» при добавлении функциональности). Большинство ошибок исправляются на стадии кодирования. Тесты пишут сами программисты; любой программист имеет право написать тест для любого модуля. Еще один важный принцип: тест определяет код, а не наоборот (такой подход носит название test-driven development), то есть кусок кода кладется в хранилище тогда и только тогда, когда все тесты прошли успешно, в противном случае данное изменение кода отвергается.

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

Существующие риски применения методологии

Следует выделить риски XP, способные завалить проект, если не учитывать и не предотвращать их.

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

Постоянное участие заказчика (on-site customer). Представитель заказчика в период работы над системой находится в команде разработчиков, причем требования к квалификации этого человека или команды весьма высоки. Если заказчик не согласился предоставить персонал уровня экспертов, то проект попадает в группу наиболее высокого риска.

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

Простая архитектура (simple design). В каждый момент времени разрабатываемая система выполняет все тесты и поддерживает все взаимосвязи, определяемые программистом, не имеет дубликатов кода и содержит минимально возможное количество классов и методов. Это правило кратко можно выразить так: «Каждую мысль формулируй один и только один раз». Данный принцип вступает в противоречие с быстротой написания кода. Без наличия высокой самодисциплины и жестких стандартов кода система немедленно попадает в группу риска.

Частая смена версий (small releases). Систему запускают в эксплуатацию уже через несколько месяцев после начала реализации, не дожидаясь окончательного разрешения всех поставленных проблем. Периодичность выпуска новых версий может варьироваться от ежедневной до ежемесячной. Протестировать за такой срок более-менее сложный компонент невозможно; заказчик фактически выступает в роли бета-тестера. Системы, к которым предъявляется требование непрерывной надежной работы (так называемое требование 24Ѕ7), входят в группу риска.

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

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

Программирование в паре (pair programming). Весь код проекта пишут группы по два человека, использующих одно рабочее место. Человеческий фактор в данном случае играет определяющую роль: пара или работает или нет, третьего не дано.

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

Коллективное владение (collective ownership). Каждый программист имеет возможность при необходимости в любое время усовершенствовать любую часть кода в системе. Без стандарта контроля исходного кода процесс разработки приобретает абсолютно неконтролируемый характер.

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

Тесты (tests). Программисты постоянно пишут тесты для модулей (unit tests). Собранные вместе, эти тесты должны работать корректно. Для этапов итерации заказчики пишут функциональные тесты (functional tests), от которых также требуется правильная работа. Однако на практике это не всегда достижимо. Чтобы принять верное решение, необходимо понять, во что обойдется сдача системы с заранее известным дефектом, и сравнить это с ценой задержки на его устранение. Тесты, написанные самими программистами (особенно в условиях сверхурочных работ), не являются полнофункциональными и уж тем более не учитывают особенностей многопользовательской работы. На более продвинутые тесты у разработчиков обычно не хватает времени. Решается данная проблема путем привлечения на определенный срок контакторов, что связано с большой ролью человеческого фактора: поскольку техническая документация изначально отсутствует, то информация передается посредством общения программистов. Хотя, конечно, можно построить систему разработки таким образом, что от начала до конца всем будут заниматься одни и те же люди. К сказанному необходимо добавить, что тестирование системы вовсе не исчерпывается тестами компонентов (units); не менее важны тесты взаимодействия между ними, это же относится и к тестам надежности работы. И тем не менее метод экстремального программирования не предусматривает создания тестов данного класса. Это объясняется тем, что сами подобные тесты могут представлять достаточно сложный код (особенно это касается тестов - имитаторов реальной работы системы). В данной технологии также никак не учитывается еще один важный класс тестов - тесты поведения системы при росте объемов обрабатываемой информации. При высокой частоте изменения версий выполнить такой тест технологически невозможно, поскольку его проведение требует стабильного и неизменного кода проекта, например в течение недели. В таком случае придется или приостанавливать разработку компонентов, или создавать на время проведения теста параллельную версию проекта, которая будет сохраняться неизменной, тогда как другая при этом будет изменяться. Затем нужно будет выполнить процесс слияния кода. Но в этом случае тест придется создавать заново, так как методы экстремального программирования просто не предусматривают разработку средств, позволяющих прогнозировать поведение системы при тех или иных изменениях. Решать данные проблемы в XP предлагается посредством все того же человеческого фактора и самодисциплины.

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

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

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