Metodologia xp

UINIVERCIDAD
DE TRUJILLO

NACIONAL

Facultad Ciencias Físicas y Matemáticas
Escuela: Ing. Informática

MONOGRAFÍA

Metodología XP
Autor: Segundo Walter Medina Tocas
Metodología e Ingeniería de Software II
Docente a cargo: Arturo Díaz Pulido

Guadalupe – PERU

01/12/2013

Metodología XP

Segundo Walter Medina Tocas

1 de diciembre de 2013

Página 2

Metodología XP


Índice General
Índice

General_________________________________________________________________________________

1

Resumen _____________________________________________________________________________________ 3
La filosofía de XP ______________________________________________________________________________ 4
Valores en XP _________________________________________________________________________________ ____5
Comunicación_______________________________________________________________________________________5
Simplicidad_________________________________________________________________________________________5
Feedback___________________________________________________________________________________________5
Coraje _____________________________________________________________________________________________6

Principios de XP _______________________________________________________________________________ 7
Rápida
Asumir

retroalimentación
la

simplicidad

_____________________________________________________________________________7

________________________________________________________________________________7

Cambios incrementales _______________________________________________________________________________7
Aceptar

el

Trabajo

cambio

de

___________________________________________________________________________________7

calidad___________________________________________________________________________________7

Otros principios _____________________________________________________________________________________7

Principales conceptos ___________________________________________________________________________ 9
Story

Cards_________________________________________________________________________________________9

Iteración

___________________________________________________________________________________________9

Refactoring________________________________________________________________________________________10
Release ___________________________________________________________________________________________10
Test de aceptación __________________________________________________________________________________10
Test unitario _______________________________________________________________________________________10

El ciclo de vida _______________________________________________________________________________ 11
Exploración

_______________________________________________________________________________________12

Planificación

_______________________________________________________________________________________12

Iteraciones

por

Producción

entregas

_____________________________________________________________________________12

________________________________________________________________________________________13

Mantenimiento _____________________________________________________________________________________13
Muerte____________________________________________________________________________________________13

Ciclo de vida del programador___________________________________________________________________ 14
Roles y responsabilidades. ______________________________________________________________________ 16
Cliente____________________________________________________________________________________________16
Coach ____________________________________________________________________________________________16
Consultant

________________________________________________________________________________________16

Manager

__________________________________________________________________________________________16

Programador
Tester

______________________________________________________________________________________16

____________________________________________________________________________________________16

Tracker ___________________________________________________________________________________________16

Prácticas ____________________________________________________________________________________ 17
40 horas
semanales__________________________________________________________________________________17Cliente OnSite_____________________________________________________________________________________17 Diseño simple
______________________________________________________________________________________17
El juego de la planificación ___________________________________________________________________________18
Estándares de codificación ___________________________________________________________________________18


Página 3

Metodología XP


Integración

continua

Metáfora

__________________________________________________________________________________________19

Pequeños

release

Programación
Propiedad

por

colectiva

________________________________________________________________________________18

___________________________________________________________________________________19
pares

_____________________________________________________________________________19

_________________________________________________________________________________19

Testing____________________________________________________________________________________________19
Refactoring________________________________________________________________________________________20

Herramientas para el testeo automático ___________________________________________________________ 21
JUnit _____________________________________________________________________________________________21

Conclusiones

_________________________________________________________________________________

23

Palabras

Claves_______________________________________________________________________________

24

Glosario

_____________________________________________________________________________________

25

Bibliografía __________________________________________________________________________________ 26

Resumen

Página 4

Metodología XP


El objetivo principal de este documento, es resumir los principales aspectos de la metodología de Extreme
Programming.
Entre otros puntos se mencionarán cuales son los valores y principios que se siguen en XP, así como también, los
principales conceptos que se deben tener en cuenta a la hora de llevarla a la práctica.
Luego se hará un análisis del ciclo de vida que se utiliza, en el cual se verá cuales son las etapas y las actividades
más importantes.
También se menciona cuales son los principales roles dentro de esta metodología, así como también, sus
responsabilidades, y además, analizaremos las prácticas más importantes que se deben seguir.
Por último haremos referencia a las herramientas de testeo automático, haciendo hincapié en la herramienta JUnit.


Página 5

La filosofía de XP
XP es una metodología ágil para pequeños y medianos equipos, desarrollando software cuando los requerimientos
son ambiguos o rápidamente cambiantes.
A diferencia de los procesos tradicionales para desarrollar software, XP asume el cambio como algo natural, y que
indefectiblemente, en alguna etapa de un proyecto sucede. En XP se realiza el software que el cliente solicita y
necesita, en el momento que lo precisa, alentando a los programadores a responder a los requerimientos cambiantes
que plantea el cliente en cualquier momento. Esto es posible porque está diseñado para adaptarse en forma
inmediata a los cambios, con bajos costos asociados, en cualquier etapa del ciclo de vida. En pocas palabras, XP
“abraza” el cambio

.Valores

en XP

Para poder implementar las prácticas que presenta XP hay que conocer cuales son los valores principales que hacen
a esta mitología. Estos valores son:






Comunicación
Simplicidad
Feedback
Coraje

Comunicación
Uno de los valores más importantes en XP es la comunicación. La mala comunicación no surge por casualidad en
un proyecto y pueden aparecer muchas circunstancias que hagan que esta falle; un programador le da malas
noticias al gerente y este lo castiga, un cliente le dice al programador algo importante y este no le presta atención.
En cualquiera de los casos la comunicación es un factor importante en cualquier tipo de proyecto. En XP se trata de
mantener una buena comunicación mediante un conjunto de prácticas que no se pueden realizar sin tener una buena
comunicación en el equipo. Muchas de estas prácticas hacen corto circuito si no hay buena comunicación como en
el caso de los testing unitarios, programación por pares, el uso de estándares o la estimación de las tareas. Trabajar
en espacios abiertos hace que la comunicación mejore al contrario de otras metodologías en las cuales los
programadores trabajan en espacios reducidos.
La comunicación con el cliente es de vital importancia en XP y es por este motivo que el cliente es integrado al
equipo. De esta forma, cualquier duda sobre los requerimientos puede ser evacuada inmediatamente. Además, se
planifica con el cliente y este puede estar al tanto del avance del proyecto. (Extreme Programming explined.
Capítulo 7. Four Values. Pág. 15)
XP ha sido diseñada para minimizar el grado de documentación como forma de comunicación, haciendo énfasis en
la interacción personal. De esta manera se puede avanzar rápidamente y de forma efectiva, realizando solo la
documentación necesaria.

Simplicidad
La simplicidad es el segundo valor que se utiliza en esta metodología. XP apuesta a realizar algo simple hoy y
destinar un poco más de esfuerzo para realizar un cambio en el futuro, a realizar algo más complicado hoy y no
utilizarlo nunca.
XP propone una regla muy simple: “hacer algo que funcione de la manera más sencilla”. En el caso de tener que
añadir nueva funcionalidad al sistema se deben examinar todas las posibles alternativas y seleccionar la más
sencilla. En otras ocasiones se hace uso del refactoring1 que permite mantener el código en funcionamiento pero
mucho más simple y organizado.
Otra regla muy importante es: “realizar solo lo necesario”. Con esto se pretende agregar nueva funcionalidad que
cumpla con los objetivos actuales sin necesidad de preocuparse por futuros requerimientos. Esto hace que se
progrese de manera más segura y rápida en el proyecto.

Feedback
Brindar un feedback correcto y preciso hace que se pueda mantener una buena comunicaci ón y conocer el estado
actual del proyecto.

1

Refactoring: Un cambio al sistema que mantiene el mismo comportamiento del sistema, pero aumenta algunos atributos de
calidad, como ser: simplicidad, flexibilidad, mantenibilidad, etc

El feedback trabaja a diferentes escalas de tiempo. Uno es el feedback ó que se realiza minuto a minuto. Cuando un
cliente escribe sus stories1 los programadores realizan la estimaci n de cada una de ellas y el cliente puede obtener
inmediatamente el feedback sobre la calidad de dichas stories.
El otro tipo de feedback que se realiza es á a través de pequeñas entregas del sistemaó. De esta manera, el cliente
está al tanto del avance del proyecto. Adem s, el sistema es puesto en producci n en menor tiempo, con lo cual los
programadores saben si realizaron un buen trabajo y si sus decisiones fueron acertadas.

Coraje
Obviamente cada uno de los valores antes mencionados tiene una gran interacción entre ellos. Como se ve en la
siguiente figura la comunicación, la simplicidad y el feedback forman el coraje, el cual se convierte en el objetivo
de XP. Uno de los lemas de XP menciona: “Si no trabajas al tope de tu capacidad, alguien más lo está haciendo y si
no llegas a tiempo se comerá tu almuerzo”.
Esto hace, a que por ejemplo, se tenga el coraje de modificar el código en cualquier momento por cualquier
miembro del equipo sabiendo que no se afectará el correcto funcionamiento del sistema.

C
comunicación

Simplicidad

Feedback

Coraje
Figura 1 – valores de XP
El coraje también es poder realizar cambios cuando algo no funciona del todo bien, diseñar e implementar solo lo
necesario para el presente, pedir ayuda o reducir el alcance de una entrega si el tiempo no alcanza.
Si no hay coraje en un proyecto no se puede clasificar como extremo y es necesario que los otros tres valores est én
presentes.
Referencias
KENT, Beck. 2000. Extreme Programming explined. 1ra edición

1

Storie: Funcionalidad que el cliente quiere que haga el sistema.

Principios de XP
Los cuatro valores mencionados anteriormente – comunicación, simplicidad, feedback y coraje – nos brindan un
estándar para obtener buenos resultados. Sin embargo, los valores son muy vagos a la hora de ayudarnos a decidir
que prácticas utilizar. Para ello se necesita destilar estos valores en principios que puedan ser utilizados.
A continuación se detallan los principios más importantes de XP.







Rápida retroalimentación
Asumir la simplicidad
Cambios incrementales
Aceptar el cambio
Trabajo de calidad

En la práctica el tiempo transcurrido entre una acción y su feedback es crítico. Tener una rápida retroalimentación
nos permite interpretarla, aprender de ella y poner en práctica lo asimilado lo antes posible.

Este es uno de los principios más difíciles de llevar a la práctica. Casi siempre se planifica para el futuro y se
diseña para poder rehusar. En lugar de esto XP dice que hay que hacer un buen trabajo para las necesidades
actuales y confiar en nuestra habilidad para solucionar problemas futuros.

Realizar grandes cambios en una sola oportunidad no es una buena solución. Cada problema debe ser resuelto con
una serie de cambios pequeños para poder atacar dicho problema mucho más en profundidad.

Aceptar el cambio
En XP el cambio es asimilado como algo habitual e inevitable. La mejor estrategia es aquella que preserva la
mayor cantidad de opciones mientras resuelve los problemas más precisos.

Trabajo de calidad
Uno de los objetivos más importantes en XP es realizar un producto de buena calidad. Si cada integrante realiza su
trabajo de la mejor manera posible se puede asegurar la calidad del producto.

Otros principios
Además de los principios antes mencionados surgen algunos otros de menor trascendencia que pueden ayudar a
tomar buenas decisiones en situaciones específicas.












Aceptar laó responsabilidad
Adaptaci n ólocal
Comunicaciñ n abierta y honesta

Ense ar conocimientos
Experimentos concretos
Jugar para ganar
Medicionesñ honestasó

Peque a inversi n inicial
Trabajar con los instintos de las personas

Viajar liviano

Aceptar la responsabilidad: Es bueno permitir que cada uno de los integrantes se ofrezca de forma voluntaria para
poder realizar una tarea determinada y que esta se comprometa ante el resto del equipo. Imponer una tarea hace que
el miembro del equipo haga algo que pueda no cumplir más adelante y pierda su motivación.
Adaptación local: Para que XP funcione de la mejor manera posible es necesario que se adapte a las condiciones
particulares de cada proyecto.
Comunicación abierta y honesta: La comunicación es uno de los pilares fundamentales en XP. Es necesario que
cada uno de los integrantes sepa exponer las consecuencias de sus propias decisiones y de las tomadas por los
demás, así como también, comunicar los problemas sin miedo de anunciar malas noticias.
Enseñar conocimientos: XP se concentra en enseñar distintas estrategias para saber como adoptar esta metodología
sin tratar de imponer ninguna de estas.
Experimentos concretos: Toda decisión que se tome a lo largo del proyecto debe ser analizada y probada para evitar
así cualquier tipo de errores.
Jugar para ganar: Todos los integrantes deben trabajar en equipo de manera agresiva y con mucho coraje para
lograr el objetivo común que es el éxito de todo el proyecto.
Mediciones honestas: Toda estimación o métrica realizada debe ser lo más lógica posible ya que no tiene sentido
dar algo tan exacto que quizás nunca se cumpla.
Pequeña inversión inicial: Al igual que la realización de un sistema en pequeñas entregas, es bueno realizar
inversiones de igual manera e ir avanzando de forma progresiva.
Trabajar con los instintos de las personas: XP está a favor de trabajar con los instintos de las personas y no en
contra de ellos. Los instintos de las personas, aquello que los incentiva, son principalmente, hacer bien su trabajo y
realizar las tareas en grupo, interactuando con el resto del equipo.
Viajar liviano: Para poder adaptarse rápidamente a los cambios constantes es bueno llevar solo lo indispensable
Referencias

Principales conceptos
Antes de comenzar a profundizar sobre la forma de trabajo de XP es bueno tener en claro algunos conceptos que
son básicos en esta metodología.
A continuación se detallan los más importantes.






Story cards
Iteration
Refactoring
Release

 Test de aceptación
 Test unitario
Story Cards
Las story cards sirven para registrar los requerimientos de los clientes y son utilizadas para poder realizar la
estimación de cada una de las iteraciones durante la fase de planificación.
Las story cards son escritas por los clientes en base a lo que se estima es necesario para el sistema. Están escritas en
un formato de oraciones en la terminología del cliente, sin necesidad de sintaxis técnicas.
También son utilizadas para poder crear los test de aceptación. Por lo general se necesitan uno o más test de
aceptación para verificar que la story ha sido implementada correctamente.
Una de las malas impresiones que generan las story cards es su diferencia con la especificaci ón de requerimientos
tradicional. La mayor diferencia es su nivel de detalle. Las story cards solo proveen suficiente detalle para poder
realizar la estimación de cuando tardará en ser implementada dicha funcionalidad. Cuando el tiempo es calculado
el programador se encarga de solicitarle al cliente una descripción más detallada de los requerimientos.
Otra diferencia entre las stories y los documentos tradicionales es que se centran en lo que el cliente necesita. Hay
que tratar de evitar en detallar la tecnología o los algoritmos. Se deben mantener las stories focalizadas en las
necesidades y los beneficios que le pueden brindar al cliente.
Cada story puede llevar entre 1 a 3 semanas en ser desarrollada en un desarrollo ideal. Este desarrollo ideal es
cuanto tiempo se tarda en implementar una story si no hay distracciones, no hay otras asignaciones y se sabe
exactamente que hacer. Más de tres semanas significa que la story debe ser dividida para ser implementada. Si
toma menos de una semana se pueden combinar con otras stories. Entre 20 y 80 stories es el número ideal para
poder crear un plan de entregas.

Iteración
Consta de un período de una a dos semanas en las cuales el cliente selecciona las stories en ser desarrolladas.
Luego de ser implementadas este cliente corre sus test funcionales para ver si la iteraci ón puede terminar de
manera exitosa.
Otro punto que no debe ser pasado por alto es el tema de la duración de cada iteración. Con iteraciones cortas se
pretende que el equipo tenga objetivos a corto plazo y pueda ver el resultado de su trabajo cada cierto tiempo y no
esperar varios meses para ver si lo que se hizo estuvo bien o no. El poder tener un reconocimiento de que se est án
haciendo bien las cosas cada cierto tiempo, hace que la persona se mantenga motivada. Además, el poder tener
retroalimentación constante con el cliente permite tener un mejor nivel en el trabajo.
También debemos considerar que las iteraciones cortas permiten hacer un diagnóstico prematuro de la situación del
proyecto, con lo cual no se debe esperar mucho tiempo en detectar posibles problemas.

Refactoring
Otro concepto muy importante es el refactoring. Consiste en realizar cambios al sistema sin modificar la
funcionalidad del mismo para poder hacer el sistema más simple, para aumentar la eficiencia o para que el código
sea mucho más entendible. Sea cual sea el objetivo del refactoring, no hay que olvidar que en XP el código es la
documentación más importante del proyecto y por ende debe estar bien desarrollado.

Release
Un release puede ser definido como un conjunto de funcionalidad que es integrada para realizar un programa
ejecutable. La idea de cada release es poder tener un producto intermedio al final de cada iteraci ón en la cual el
cliente pueda testear la funcionalidad pedida. Con esto los clientes pueden, además, ver el avance del proyecto y
poder realizar comentarios a los programadores y no esperar hasta el final del mismo cuando esté todo integrado.

Test de aceptación
Los test de aceptación representan algún tipo de resultado por parte del sistema. Los clientes son los responsables
de verificar la exactitud de estos test y de revisar los resultados para poder así priorizar los test que fracasaron.
También son utilizados como test regresivos antes de entrar a la fase de producción.
Una story no es aceptada hasta que haya pasado su test de aceptación. Esto significa que en cada iteración se deben
realizar nuevos test de aceptación o de lo contrario el equipo tendrá una avance de cero.
Estos test suelen ser automatizados para que puedan ser ejecutados frecuentemente. El resultado de cada test es
publicado para el resto del equipo.
El nombre de test de aceptación refleja la verdadera intención, la cual es garantizar a los clientes que los
requerimientos han sido realizados y el sistema es aceptable.

Test unitario
Los testing unitarios son tan importantes como los test de aceptación. Son realizados desde el punto de vista del
programador y sirven, además de testear el código, para poder realizar el refactoring del mismo.
Cada programador, antes de comenzar a programar, debe preparar los test unitarios. Esto hace que dichos test est én
preparados para ser corridos durante la codificación y además, hace que al programador le surjan dudas y pueda
evacuarlas con el cliente antes de empezar con la codificación.
Referencias

Extreme Programming <http://www.extremeprogramming.orgEl

ciclo de vida

El ciclo de vida de XP consiste básicamente de seis fases: Exploración, Planificación, Iterations to Release,
Producción, Mantenimiento y Muerte.

1-

Exploración

En esta fase los clientes realizan las story cards que desean que estén para la primera entrega. Cada story describe
una de las funcionalidades que el programa tendrá. Al mismo tiempo el equipo de desarrollo se familiariza con las
herramientas, la tecnología y las prácticas a ser utilizadas durante el proyecto. En algunos casos se utiliza un
prototipo para testear la nueva tecnología y explorar algunos aspectos de la arquitectura a ser implementada. La
duración de esta fase puede extenderse desde unas pocas semanas a varios meses dependiendo de la adaptación del
equipo de desarrollo.

2-

Planificación

El objetivo de esta fase es fijar la prioridad de cada una de las stories y se establece cual va a ser el contenido de la
primera entrega. Los programadores estiman cuanto esfuerzo requiere cada story y se establece el cronograma. La
duración del calendario para la entrega del primer release no suele superar los dos meses. Duración de la fase de
planificación en sí no toma más de dos días.

3-

Iteraciones por entregas

Esta fase incluye varias iteraciones del sistema antes de la entrega del primer release. El calendario es dividido en
un número iteraciones de tal manera de que cada iteración tome de una a cuatro semanas de implementación. En la
primera iteración se crea un sistema que abarca los aspectos más importantes de la arquitectura global. Esto se
logra seleccionando las stories que hagan referencia a la construcción de la estructura de todo el sistema.
El cliente decide que stories van a ser implementadas para cada iteración. Además, se realizan los test funcionales,
realizados por el cliente, al final de cada iteración. Al final de la última iteración el sistema está listo para ser
puesto en producción.

4-

Producción

La fase de producción requiere realizar muchos más chequeos y testing antes que el sistema sea entregado al
cliente.
En esta fase aparecen nuevos cambios y se tiene que decidir si serán incorporados o no en dicha entrega. Durante
esta fase suele suceder que las iteraciones se aceleren de tres a una semana. Las ideas pospuestas y las sugerencias
son documentadas para luego ser implementadas más adelante, por ejemplo, en la fase de mantenimiento.
Luego que el primer release es creado, el proyecto debe mantener el sistema en producción corriendo mientas se
trabaja en las nuevas iteraciones.

5-

Mantenimiento

En esta fase por lo general se necesita un esfuerzo extra de los programadores para satisfacer los requerimientos del
cliente. Por este motivo la velocidad de desarrollo suele disminuir una vez que el sistema es puesto en producci ón.
A raíz de esto se requiere incorporar nuevos integrantes al equipo y cambiar la estructura del equipo.

6-

Muerte

Esta última fase se acerca una vez que el cliente no tiene ninguna story a ser implementada. Los requerimientos del
sistema deben ser satisfechos en otros aspectos como ser la performance o la confiabilidad del mismo. Esta es la
etapa en la cual no hay más cambios en la arquitectura, el diseño o el código y aquí es cuando se realiza la
documentación correspondiente. Esta fase aparece también, cuando el sistema no da los resultados deseados o se
vuelve demasiado caro para seguir siendo desarrollado.

Figura 2 – Ciclo de vida de XP

Exploración
Dorantes esta fase los programadores utilizan cada parte de la tecnología a ser usada durante el proyecto. Se
exploran todas las posibilidades que puede tener la arquitectura del sistema. Se utilizan una o dos semanas para
construir prototipos que implementen la funcionalidad básica pero de dos o tres formas distintas.
Si una semana no alcanza para explorar una parte de la tecnología esto puede clasificarse como un riesgo. Esto no
significa que no se pueda utilizar pero sí sería bueno explorarla con más detalle y considerar alternativas.
Los programadores suelen estimar la duración de cada tarea realizada durante esta fase. Cuando finaliza una tarea
se reporta en el calendario el tiempo requerido.
Mientras los programadores trabajan con la tecnología, los clientes escriben las stories. Al principio las stories no
son las que se esperan. La clave es darle rápidamente al cliente una feedback de las primeras stories para que
aprendan en seguida a como especificar lo que los programadores necesitan.

Planificación
El propósito de esta fase es el de llegar a un acuerdo entre los clientes y los programadores en cuales serán las
stories a ser implementadas durante cada iteración. Si se hace una buena preparación durante la fase de exploración
esta actividad no suele llevar más de un día o dos.

La entrega del primer release debe tomar entre dos a seis meses de duración. Si se planifica realizarla en menos
tiempo es probable que no se tengan los elementos necesarios para solucionar los problemas más significativos.
Pero si se tarda más de este período se corre el riesgo que el cliente no quede satisfecho.

Iteraciones por entregas
Una vez elegido el orden en el cual se implementarán las stories se procede a definir cuantas iteraciones serán
necesarias para el proyecto. Cada iteración tiene una duración de una a cuatro semanas, en las cuales se realizan los
test funcionales para cada una de las stories a ser implementadas.

La primera iteración suele servir para definir la arquitectura de todo el sistema. Es por este motivo que se
seleccionan las stories que definen la arquitectura aunque solo formen una base del mismo.
La selección de las stories para las siguientes iteraciones suele quedar al criterio del cliente. El cliente debe
seleccionar las stories que tengan más interés para él de las que falten ser implementadas.
Además de la implementación, se debe llevar un control con respecto a las desviaciones del calendario. Cuando se
detectan desviaciones es necesario tomar medidas. Quizás se deba agregar o remover stories o quizás deba
encontrar una mejor manera para utilizar la tecnología e incluso para utilizar XP.
Al final de cada iteración el cliente debe analizar que todas las stories estén implementadas. Debe también correr
todos los test funcionales y que estos resulten ser exitosos.

Producción
En esta fase es donde el producto se pone en producción y se realizan todas las pruebas de preformase del sistema.
Este es el momento en donde se afinan los detalles del sistema debido a que se tiene un gran conocimiento del
diseño y además, se dispone del hardware en donde se va a correr el sistema.
Durante esta fase se debe ir más despacio a medida que se desarrollando el software. Esto no significa que el
desarrollo se detenga pero si es de considerar, que el riesgo se vuelve más importante a medida que los cambios
afecten al release.

Mantenimiento
En esta fase se debe agregar nueva funcionalidad, mantener el sistema corriendo e incorporar nuevos integrantes al
equipo.
Se hacen los refactoring que no se pudieron realizar anteriormente. Además, se prueba la nueva tecnología que se
va a utilizar en el próximo release o migrar a nuevas versiones de la tecnología que se está utilizando. También se
suele experimentar con nuevas ideas para la arquitectura actual y el cliente suele escribir nuevas stories que puedan
mejorar el sistema.
El trabajar sobre un sistema que está en producción no es lo mismo que hacerlo sobre un sistema que aún está
siendo desarrollado. Hay que ser muy cuidadoso sobre los cambios a ser realizados.
Otros de los puntos que se debe considerar en esta fase es la incorporación de nuevos integrantes al equipo de
desarrollo. Es bueno darle dos o tres iteraciones donde ellos hagan muchas preguntas, trabajen en parejas y lean
mucho código y casos de prueba. Cuando ellos se sientan listos, pueden ser puestos a trabajar en algunas tareas de
programación y así hasta que queden completamente integrados. Si el equipo va cambiando gradualmente durante
un año se puede reemplazar sin desestabilizar la forma de trabajo que se lleva.

Muerte
Hay dos buenas razones por la cual el sistema entre en esta fase. La primera puede ser debido a que el cliente est é
muy satisfecho con el sistema y no tenga ninguna otra funcionalidad que agregar en el futuro. La otra raz ón suele
ser que el sistema no termina de ser liberado. El cliente necesita más funcionalidades y es imposible costearlas.
Otro motivo puede ser que los defectos detectados alcancen un nivel intolerable.
Referencias
ABRAHAMSSON, Pekka; SALO, Outi; JUSSI. Agile softwar development methods. Reviews and analysis
[online].
Disponible en Internet: http://www.info.vtt.fi.pdf/

Ciclo de vida del programador
Además del ciclo de vida común de XP podemos encontrar otro ciclo de vida dentro de este que indica como
trabajan los programadores para poder codificar.

ELECCIÓN DE PARES

Q
&
A

TESTING

CODIFICACIÓN

REFACTORING

INTEGRACIÓN

Figura 3 – Ciclo de vida del programador
El triángulo que se encuentra en el medio de la figura 3 es la clave principal en la idea de XP. En ellas se muestra la
forma de trabajo: Testing, codificación y luego refactoring. Esto es lo opuesto a la programación tradicional en
donde primero se diseña, luego se codifica y por último se testea.
Veamos en detalle cada una de las actividades:



Elección de pares
o Toda la producción se realiza en pares.
o El encargado de escribir piensa tácticamente, su pareja piensa estratégicamente.

o




Se rotan los roles periódicamente.

Testing
o Se escriben los testing unitarios.
o Se verifica que los test fallen antes de codificar.
o Se testea todo lo que posiblemente puede fallar.
Codificación
“Hacer algo que funcione de la manera más sencilla”
Implementar lo suficiente para hacer que el test pase.
Seguir el estándar de codificación.

o
o
o


Refactoring
Quitar toda porción de código que no parezcan estar bien y luego verificar si el código aún pasa los
test unitarios.
o El código debe ser claro, no tener partes duplicadas y tener la menor cantidad de clases y métodos
posibles.
Realizar cambios pequeños y luego realizar los test unitarios.
Q &A
o El cliente puede proveer rápidamente cualquier respuesta on-site.
o Muchas preguntas requieren decisiones y el cliente debe estar preparado para poder hacerlas.
o El cliente suele escribir una story o un test de aceptación que captura sus preguntas.

o



Integración
o Llevar el código a la máquina donde se realiza la integración, unir el sistema y correr todos los
test.
o Arreglar todos los errores para que pasen todos los test unitarios.
o Si no es fácil la integración es mejor tirar todo y comenzar nuevamente al día siguiente.



Retornar al inicio.
o Si resta tiempo, se puede elegir otra pareja o cambiar de roles y comenzar con otra actividad.

Referencias
Extreme Programming < http://www.xp123.com>

Roles y responsabilidades.
Dentro de la mitología de XP existen variados roles. A continuación se detallan cuales son los roles más
importantes.

Cliente
Es quien establece que es lo que debe realizar el sistema, tomando la decisión de cuando se debe implementar
determinada funcionalidad, así como también en el orden a ser implementadas. Además, el cliente escribe las story
cards y los test funcionales y decide cuando cada requerimiento está satisfecho. Los clientes también priorizan cada
uno de los requerimientos.

Coach
Es el encargado de asegurar el cumplimiento de todas las prácticas, transmitiendo sus conocimientos y experiencia
al resto del equipo.
al resto del equipo.al resto del equipo.

Consultant

Es una persona externa al equipo que posee el conocimiento técnico necesario para poder ayudar al equipo con
determinados problemas.

Manager
Toma las decisiones más importantes del proyecto. Es el encargado de comunicarse con el equipo para determinar
cual es la situación actual y distinguir cualquier dificultad o deficiencia en el proceso y poder solucionarlo.

Programador
Es el responsable de escribir los testing del sistema y mantener el códigoó lo más simple y definitivo posible. El
primer aspecto a tener en cuenta para que XP sea exitoso es la coordinaci n entre los programadores y el resto del
equipo.

Tester
Los tester ayudaní a los clientes a escribir los test funcionales del sistema. Además, corren dichos testing
regularmente, env an los informes con los resultados y realizan el mantenimiento a las herramientas de testing.

Tracker
Tiene como principal responsabilidad realizar las mediciones y la recolección de métricas. Mide el progreso del
proyecto y lo compara con lo estimado. También observa el desempeño del equipo, haciendo énfasis en el
cumplimiento de los plazos y aconsejando al equipo si deben realizar cambios para lograr los objetivos. Además de
todo esto, mantiene los registros de los casos de prueba ejecutados, los defectos encontrados y sus responsables.
Referencias
ABRAHAMSSON, Pekka; SALO, Outi; JUSSI. “Agile softwar development methods. Reviews and
analysis”[online]. Disponible en Internet: <http://www.info.vtt.fi.pdf/>

Prácticas
Uno de los factores que hacen que XP sea tan utilizado y efectivo son las pr ácticas que se realizan durante el
proyecto. XP es un conjunto de ideas y prácticas de metodologías ya existente y por eso deben ser muy tenidas en
cuenta a la hora de su implementación. A continuación se presentan las prácticas más utilizadas.














40 Horas semanales
Cliente on-site
Diseño simple
El juego de la planificación
Estándares de codificación
Integración continua
Metáfora
Pequeñas entregas
Programación por pares
Propiedad colectiva
Testing
Refactoring

40 horas semanales
Como máximo se puede trabajar un promedio de 40 horas semanales. No se permite trabajar tiempo extra durante
dos semanas seguidas. Si esto ocurre, se trata de un problema a ser solucionado.
El no tener que realizar horas extras hace que los integrantes puedan disponer de tiempo libre para poder descansar
y realizar otras actividades. De esta forma la productividad del equipo se mantiene alta y se reducen los problemas
por falta de descanso.
Como en los proyectos suelen haber retrasos se está permitido poder realizar, en una semana, una mayor cantidad
de horas que las establecidas. Pero solamente durante una semana, ya que si sigue el atraso, es un indicador de que
algo malo sucede con el proyecto y el tener mayor carga horaria a la larga no es la solución.
El realizar horas extras más de una semana seguida hace que se comentan más errores tanto en el código como en
el diseño. Esto hace que la calidad del producto realizado sea menor y a largo plazo ese tiempo supuestamente
recuperado se pierde debido a estos problemas.

Cliente On-Site
El cliente debe estar presente y disponible en todo momento para el equipo.
El contar con el cliente on-site permite al equipo poder evacuar cualquier tipo de duda que pueda surgir. Adem ás de
esto, el cliente puede observar cual el grado de avance del proyecto mientras se construye el sistema.
La mayor ventaja de todas es que se puede crear una comunicación fluida con el cliente sin necesidad de gastar
tiempo en documentación formal. Esta comunicación constante reduce el tiempo de desarrollo al reducir las
esperas por respuesta y los malentendidos entre ambas partes.

Diseño simple
Se hace mucho énfasis en el diseño de una solución lo más simple posible que pueda ser implementada en el
momento. El código complejo o innecesario es eliminado inmediatamente.
En XP el diseño se hace en forma progresiva lo cual evita que se cree un diseño altamente complejo por querer
abarcar todos los aspectos posibles de una sola vez. Un buen diseño debe cumplir los siguientes puntos:
Corre todo los casos de prueba
§
§

Enuncia todas las ideas que se quieren exhibir.
No tiene código duplicado

§

Posee el menor número de clases y métodos posibles.

Para poder obtener un diseño simple se descartan todos aquellos elementos innecesarios mientras que los tres
primeros puntos se cumplan

Para poder realizar una buena planificación se necesita una buena interacción entre los clientes y los
programadores.
Los programadores estiman el esfuerzo necesario para cada una de las stories y los clientes deciden sobre el
alcance y el momento en el que debe realizar cada entrega.
En el plan de entregas, el cliente elige aquellas stories que crea son más importantes para implementar. Cada
entrega debe tener una duración máxima de dos meses y se estima la duración suponiendo que no hay retrasos o
imprevistos.
Cada entrega consta de varias iteraciones, cuya duración no debe superar las dos semanas. En el plan de
iteraciones, el cliente selecciona las stories a ser implementadas, y se detallan las pruebas de aceptación para cada
story. Los programadores dividen cada story en tareas, que luego son aceptadas por cada programador, estimadas,
implementadas y por último integradas al sistema.
Las tareas tienen una duración promedio de uno a dos días. En ellas los programadores establecen todos los casos
de prueba posibles antes de comenzar con la implementación. Luego se pasa a la implementación en el cual el
cliente está disponible para poder evacuar cualquier duda que surja.

El código es la mejor documentación que tiene el sistema. Es por este motivo que se deben establecer reglas para
los programadores y estas deben ser seguidas estrictamente.
En un equipo de desarrollo los programadores acuerdan un estándar para el código, dejando de lado estilos de
programación particulares. Todos deben conocer y seguir el estándar de manera tal que al final el sistema parezca
ser programado por una sola persona.
Algunos de los puntos a tener en cuenta son los siguientes:







Mantener métodos pequeños (el código puede ser visto en una sola pantalla)
Ser coherentes en el uso de mayúsculas.
Solo comentar el código cuando sea realmente es necesario.
Usar formatos de nombres consistentes y similares.
Utilizar siempre el mismo formato de sangría.

Una nueva pieza de código debe ser integrada al resto del sistema tan pronto como sea posible. De ese modo, el
sistema es integrado y reconstruido varias veces por día.
Para poder realizar esta integración se selecciona una computadora determinada. Luego, al finalizar cada pareja de
programadores se dirige a dicha máquina para integrar sus cambios al sistema existente. Posteriormente se ejecutan
todos los casos de prueba establecidos, hasta que cada uno de ellos sea aprobado.
Lo bueno de este sistema es que no ocurren problemas de integración ya que los errores se encuentran y se
solucionan al momento de ser integrados por los mismos programadores que tienen en la cabeza en código
implementado. Esto evita que se pasen meses para la integración y tener que solucionar estos problemas más
adelante.

Metáfora
El sistema es definido en base a una metáfora o conjuntos de metáforas entre el cliente y los programadores.
Para XP la metáfora equivale a la arquitectura en otras metodologías, pero es más formal y sencilla. Es utilizada
por los programadores para describir a grandes rasgos la estructura del sistema de manera tal que pueda ser
comprendida por todos los integrantes.

Una vez que la metáfora es creada, se pasa al establecimiento de clases, métodos y relaciones primordiales del
sistema.
Además, de servir como fuente de comunicación entre los clientes y los programadores sirve para poder mantener
el diseño del sistema lo más simple posible. También se utiliza para comunicar las bases del sistema a los nuevos
integrantes.

Pequeños reléase
Los release deben ser los más pequeños posibles con una duración no mayor a dos meses. Esto permite que los
clientes puedan ver el avance del proyecto y los programadores puedan retroalimentarse de las opiniones de los
clientes.
Por lo general estos release comienzan implementando las características primordiales del sistema. Luego a medida
que avanza el proyecto se van agregando el resto de las funcionalidades.
El poder tener un producto terminado cada cierto tiempo hace que el cliente vea como va tomando forma su
producto y además hace que los programadores mantengan su nivel de motivación ya que lo más agradable de
programar es poder entregar un producto terminado.

Uno de los pilares de XP es la programación en pareja o programación por pares. Básicamente lo que se quiere con
esto es poder eliminar posibles errores debido a distracciones o errores conceptuales. Al tener dos personas
concentradas sobre el mismo código se evitan estos errores y se ahorra tiempo en futuras correcciones.
Una de las dos personas es el “conductor”, que es el encargado de escribir el código. La otra persona, el “copiloto”,
participa verbalmente. El “conductor” tiene una visión de cómo implementar el código de la mejor manera
mientras que el “copiloto” tiene una visión global del sistema y se encarga de sugerir posibles alternativas y nuevos
casos de prueba. Es bueno que los dos integrantes se turnen en la conducción.

Propiedad colectiva
Cualquier persona está en condiciones de cambiar cualquier parte del código en cualquier momento.
En XP nadie tiene propiedad sobre ningún módulo o clase. Cada uno de los integrantes puede realizar cambios o
mejoras a cualquier parte del código en cualquier momento. Esto hace que el sistema cuente con una menor
cantidad de defectos y por ende una mejor calidad.

Testing
Otro de los puntos importantes de XP son los testing, los cuales se realizan continuamente. Existen dos tipos de
testing; testing unitario y testing funcionales o de aceptación.
Los testing unitarios son implementados por los programadores antes de comenzar con la implementación. Se
establecen todos los casos en el que el código puede fallar. Una vez que se termina con la implementación se corren
dichas pruebas y se verifica que no haya ningún test que falle. Hasta que pasen todos los test el programador debe
seguir mejorando el código. Estas pruebas son automatizadas e implementadas por el propio programador, lo cual
hace que la prueba pueda ser más rápida y efectiva
.

Los testing funcionales o de aceptación son definidos y escritos por el cliente al inicio de cada iteración para cada
una de las stories establecidas. El objetivo es demostrar al cliente que el requerimiento implementado realmente
funciona como el cliente lo desea.

Refactoring
El refactoring del código hace que este sea fácil de entender y de mantener sin modificar su comportamiento.
En XP el refactoring se realiza permanentemente en base a estar respaldados por efectivos casos de prueba. Como
resultados, la cantidad de errores disminuye, lo cual mejora la calidad del software. El dise ño se mantiene simple y
permite a los programadores desarrollar más rápido.
Referencias
[online]. Disponible en Internet: <http://www.info.vtt.fi.pdf/>

Herramientas para el testeo automático
Debido a que el testing es una de las actividades más importantes en la programación de XP es necesario poseer
una buena herramienta de testeo automático según el tipo de lenguaje en el cual se desarrolle.
Una de las herramientas más conocida para realizar el testing automático es JUnit. Esta herramienta sirve para los
programadores que desarrollan en JAVA pero en el mercado hay otros tipo de JUnit para los distintos lenguajes.
El objetivo de esta sección no es mostrar el funcionamiento de JUnit, sino que se desea ejemplificar como se puede
implementar el testeo automático.

JUnit
Caso simple
Para poder realizar un test simple en algún método simplemente se debe hacer lo siguiente:
Crear una instancia de TestCase
·
Crear un constructor el cual acepte un String como parámetro y pasar este como superclase.
·
Reescribir el método runTest()
·
Cuando se quiere chequear un valor, llamar al assertTrue() y pasarle un boolean que
método
sea
·
verdadero cuando el test sea correcto.
Por ejemplo, para poder étestear el funcionamiento del método “concatenar” de la clase “Cadena” se puede
implementar el siguiente m todo.
Public void testConcatenar()

{

Cadena cadena1 = new Cadena (“Hola ”);
Cadena cadena2 = new Cadena (“Juan”);
Cadena resultado = cadena1.concatenar(cadena2);
Cadena valorEsperado = new Cadena(“Hola Juan”);
asserTrue(valorEsperado.equals(resultado));

}
Suite
A medida que se avanza con la implementación es lógico que aparezca la necesidad de realizar varios test y es
bueno poder correrlos todos a la vez si necesidad de correrlos uno por uno. Para ello JUnit provee un objeto
llamado TestSuite el cual permite correr cualquier cantidad de test al mismo tiempo.
Por ejemplo, para correr un test simple, se ejecuta:
TestResult resultado = (new CadenaTest (“testConcatenar()”)).run();
Pero para poder realizar el testeo de dos casos al mismo tiempo se debe realizar lo siguiente:
TestSuite suite = new TestSuite();
suite.addTest(new CadenaTest(“testEquals”);
suite.addTest(new CadenaTest(“testConcatenar”);
TestResult resultado = suite.run();
TestRunner
Una vez que los test suite están implementadoséá es hora de suiterecolectar la información de cadaJUnituno de dichos
test. Para esto es necesario implementar un m todo est tico llamado que retorna un test suite. ( . JUnit CookBook )

Por ejemplo, para el caso de la “Cadena” es necesario implementar lo siguiente:
Public static Test suite()
{

}

TestSuite suite = new TestSuite(); “ ” suite.addTest(new
CadenaTest(“testEquals
);
” suite.addTest(new
CadenaTest( testConcatenar ); TestResult resultado =
suite.run();

JUnit provee distintos tipos de testing (TestRunner):
 Textual TestRunner: Este es mucho más rápido de ejecutar y puede ser utilizado cuando no es necesario
tener información gráfica de los resultados del testing.
 Graphical TestRunner: Este muestra un simple diálogo en el cual se elige el test a ejecutar y provee una
gráfica de progresión de los test realizados.
El Graphical TesRunner muestra una ventana con la siguiente información:
 Un campo donde se indica el nombre de la clase con el método suite.
 Un botón Run que comienza el testeo.
 Una barra de progreso la cual se torna de roja a verde en el caso que un test falle.
 Una lista de los test fallados.
En el caso que un test falle se reporta este caso en la lista de abajo.

Con este tipo de herramientas el testing es mucho más fácil de implementar y se obtienen los beneficios que hemos
explicado anteriormente, como por ejemplo, el refactoring.
Referencias
JUnit <http://www.junit.com>

Conclusiones
Como hemos visto en este documento hay aspectos en XP que lo hacen diferente a otras metodologías.
Comenzamos con sus valores (Comunicación, Simplicidad, Feedback y Coraje). En XP la comunicación es
vital¡ tanto entre el grupo de desarrollo como con el cliente, el cual debe formar parte del equipo para mantener una
comunicación fluida y poder de esta forma, evacuar cualquier tipo de duda que surja con los requerimientos. La
simplicidad apuesta a realizar algo simple hoy y destinar un poco más de esfuerzo para realizar un cambio en el
futuro, a realizar algo más complicado hoy y no utilizarlo nunca. El feedback constante entre el equipo y el cliente
hace que se pueda conocer el estado actual del proyecto y poder así tomar decisiones mucho más acertadas. Por
último, la comunicación, la simplicidad y el feedback forman el coraje, el cual se convierte en el objetivo de XP. El
coraje también es poder realizar cambios cuando algo no funciona del todo bien, diseñar e implementar solo lo
necesario para el presente, pedir ayuda o reducir el alcance de una entrega si el tiempo no alcanza.
Los cuatro valores mencionados anteriormente nos brindan un estándar para obtener buenos resultados. Sin
embargo, los valores son muy vagos a la hora de ayudarnos a decidir que prácticas utilizar. Para ello se necesita
destilar estos valores en principios que puedan ser utilizados, como ser, una rápida retroalimentación, asumir la
simplicidad, realizar cambios incrementales, aceptar el cambio y realizar un trabajo de calidad.
Por último debemos mencionar las prácticas que se utilizan, las cuales hacen que XP sea tan utilizado y efectivo.
XP es un conjunto de ideas y prácticas de metodologías ya existente y por eso deben ser muy tenidas en cuenta a la
hora de su implementación. De la gran cantidad de prácticas destacamos:














40 Horas semanales
Cliente on-site
Diseño simple
Metáfora
Pequeñas entregas
Propiedad colectiva
Testing
Refactoring

Todos estos puntos antes mencionados hacen permiten que se realice el software que el cliente solicita y necesita,
en el momento que lo precisa, alentando a los programadores a responder a los requerimientos cambiantes que
plantea dicho cliente en cualquier momento.
No debemos olvidar que la base de XP es que el proceso se mantenga ágil en todo momento, lo cual significa que
se pueda adaptar al cambio sin mayores complicaciones. Por este motivo los conceptos antes mencionados no
deben ser impuestos bajo ningún tipo de concepto sino que al contrario deben servir como una guía según el tipo de
proyecto que se quiera realizar.

Palabras Claves

















































40 Horas semanales
Aceptar el cambio
Aceptar la responsabilidad
Adaptación local
Cliente
Cliente on-site
Coach
Comunicación
Comunicación abierta y honesta
Consultant
Coraje
Diseño simple
Enseñar conocimientos
Entrega
Fase de exploración
Fase de iteraciones por entregas
Fase de mantenimiento
Fase de muerte
Fase de planificación
Fase de producción
Feedback
Jugar para ganar
Manager
Mediciones honestas
Metáfora
Pequeña inversión inicial
Pequeñas entregas
Programador
Propiedad colectiva
Refactoring
Simplicidad
Sotries
Story cards
Test funcional
Tester
Testing unitarios
Trabajar con los instintos de las personas
Trabajo de calidad
Tracker
Viajar liviano

Glosario
ü

Refactoring: Un cambio al sistema que mantiene el mismo comportamiento del sistema, pero aumenta algunos
atributos de calidad, como ser: simplicidad, flexibilidad, mantenibilidad, etc.

ü

Release: Conjunto de funcionalidad que es integrada para realizar un programa ejecutable.

ü

Story cards: Ficha en la cual el cliente especifica una funcionalidad en particular.

ü

Story: Funcionalidad que el cliente quiere que haga el sistema.

ü

Test de aceptación: Test escrito desde la perspectiva del cliente.

ü

Test unitario: Test escrito desde la perspectiva del programador.

Bibliografía
Artículos
[online].Disponible en Internet: http://www.info.vtt.fi.pdf/
Libros
Sitios Web
Extreme Programming <http://www.extremeprogramming.org>
Extreme Programming < http://www.xp123.com>
JUnit <http://www.junit.com>

Metodologia xp

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Metodologia xp

Similar to Metodologia xp (20)

Recently uploaded

Recently uploaded (20)

Metodologia xp