Introducción a la metodología XP
¿En qué consiste XP?
La Programación Extrema es una metodología ligera de desarrollo de
software que se basa en la simplicidad, la comunicación y la
realimentación o reutilización del código desarrollado.
Origen de la metodología XP
Desarrollada por Kent Beck.
Las cuatro variables
- Coste: Máquinas, especialistas y oficinas
- Tiempo: Total y de Entregas
- Calidad: Externa e Interna
- Alcance: Intervención del cliente
El coste del cambio
Uso de la metodología XP
- XP surgío como respuesta y posible solución
a los problemas derivados del cambio en los
requerimientos
- XP se plantea como una metodología a
emplear en proyectos de riesgo
- XP aumenta la productividad
Trabajando con Extreme Programming
Fases del la Metodología XP
Historias de usuario
- Las historias de usuario tienen el mismo propósito que los casos de uso.
- Las escriben los propios clientes, tal y como ven ellos las necesidades del
sistema.
- Las historias de usuario son similares al empleo de escenarios, con la
excepción de que no se limitan a la descripción de la interfaz de usuario.
También conducirán el proceso de creación de los test de aceptación
(empleados para verificar que las historias de usuario han sido
implementadas correctamente).
- Existen diferencias entre estas y la tradicional especificación de
- requisitos. La principal diferencia es el nivel de detalle. Las historias de
- usuario solamente proporcionaran los detalles sobre la estimación del
- riesgo y cuánto tiempo conllevará la implementación de dicha historia de
- usuario.
Un plan de iteración puede verse como:
Iteraciones y planes de iteración:
Rotaciones
- La rotaciones evitarán que las personas se conviertan en si mismas en
un cuello de botella. Las rotaciones permitirán que todo el mundo
conozca cómo funciona el sistema.
Reuniones
- Reuniones de seguimiento diarias
Correcciones
- Deberemos corregir el proceso cuando éste falle.
- Todo el mundo debe estar al corriente de los cambios.
- Para que esto funcione correctamente hay que crear unidades de prueba de cada módulo que se desarrolle.
En esta MIDLET estaremos usando la clase "GameCanvas" para desarrollar un pequeño videojuego para el movimiento de un personaje en nuestro celular.
Tipo: Midlet
capa.java_________________
package frames.manager;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class Capa extends MIDlet {
JuegoGameCanvas3 juego;
Display display;
public void startApp() {
display=Display.getDisplay(this);
juego=new JuegoGameCanvas3(true);
display.setCurrent(juego);
Thread t=new Thread(juego);
t.start(); //
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
}
__________________________
Tipo: Clase Java
JuegoGameCanvas3.java_________________
package frames.manager;
import java.io.IOException;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;
import java.lang.*;
public class JuegoGameCanvas3 extends GameCanvas implements Runnable{
//variables
int width;
int height;
int coordX=0;
int coordY=0;
int coordXSprite;
int coordYSprite;
final static int WIDTH_VW=180;
final static int HEIGHT_VW=177;
Image tiled=null;
Image sprited=null;
LayerManager lm;
TiledLayer tl;
Sprite sprite;
Graphics g;
//constructor
public JuegoGameCanvas3(boolean b){
super(b);
//Inicializacion de variables
width=getWidth();
height=getHeight();
g=getGraphics();
//Layer manager en el que colocar los distintos
//elementos visuales que componen la aplicacion
lm=new LayerManager();
//inicializacion de tiledlayer
try{
tiled=Image.createImage("/frames/manager/tiledLayer.png");
}catch(java.io.IOException e){
}
tl=new TiledLayer(20,11,tiled,16,16);
try{
sprited=Image.createImage("/frames/manager/imgSprite.png");
}
catch(java.io.IOException e){
}
int[]map={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,6,1,1,1,1,6,6,1,1,1,1,1,1,1,1,1,1,6,
1,5,3,4,1,1,5,3,3,4,1,1,1,1,1,1,1,1,5,3,
5,3,3,3,4,5,3,3,3,3,4,1,1,1,5,3,3,3,3,3,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
for(int i=0;i
int column=i%20;
int row=(i-column)/20;
tl.setCell(column, row, map[i]);
}
//hacemos visible el tiledLyer que dibuja el fondo
tl.setVisible(true);
//Sprite que representa la animacion
sprite=new Sprite(sprited,15,25);
int[]sequence={0,1,2,3};
coordXSprite=width/2;
coordYSprite=112;
sprite.setFrameSequence(sequence);
sprite.defineReferencePixel(0,25);
sprite.setRefPixelPosition(coordXSprite, coordYSprite);
sprite.setTransform(Sprite.TRANS_MIRROR);
sprite.setVisible(true);
//añadimos los distintos layers al LayerManager
lm.append(sprite);
lm.append(tl);
//Definimos la ventana visible y la dibujamos
lm.setViewWindow(0, 0,WIDTH_VW, HEIGHT_VW);
lm.paint(g, 0, 0);
flushGraphics();
}
public void run(){
while(true){
try{
//Actualizar el estado del juego
int keyState=this.getKeyStates();
if(keyState!=0){
this.actualizaPosicion(keyState);
lm.setViewWindow(coordX, coordY, WIDTH_VW, HEIGHT_VW);
sprite.setRefPixelPosition(coordXSprite,coordYSprite);
//Responder a la pulsacion de teclas,
//repintando aqui por ejemplo
lm.paint(g, 0, 0);
flushGraphics();
//Esperemos
Thread.sleep(50);
}
}catch(Exception e){
System.out.println(e);
}
}
}
//Actualiza la posicion del Sprite en funcion de la accion ejecutada
public void actualizaPosicion(int key){
switch(key){
case 4:
if(coordX > 3){
coordX -=4;
sprite.prevFrame();
coordXSprite-=4;
}
break;
case 32:
if(coordX
coordX +=4;
sprite.nextFrame();
coordXSprite+=4;
}
break;
case 2:
if(coordY
coordY -=4;
sprite.nextFrame();
coordYSprite-=4;
}
break;
case 64:
if(coordY
coordY +=4;
sprite.prevFrame();
coordYSprite+=4;
}
break;
}
}
}
______________________________________
Archivo Imagen que se usaron:
imgSprite.png
