INGENIERÍA DE SOFTWARE AVANZADA

PROGRAMACIÓN POR PARES

Para trabajar en esta práctica Ud. debe tener un socio, y pueden trabajar conjuntamente en
el desarrollo de los ejercicios.
Los ejercicios alientan a Usted y a su socio a alternar la digitación del código y el
razonamiento sobre el problema. Enfatiza en el beneficio de la programación por pares y
cuan divertido puede ser este tipo de desarrollo. También, muestra como los beneficios del
negocio se pueden dar y como promover mejor estas ideas para su organización.
La programación por pares es la práctica para desarrollar todo el código de producción con
dos desarrolladores sentando en una máquina. La meta de esta práctica es que los
desarrolladores se ayuden mutuamente, logrando mucho más que un solo desarrollador.

EJERCICIO UNO
Juego para enseñar programación por pares
Este juego se basa en el juego llamado perfección (Perfection Game). Para jugarlo se
necesita una computadora personal con un teclado, un mouse, las herramientas de
desarrollo .NET Framework instaladas, suficiente sillas y espacio para que todos los
desarrolladores pueden sentarse y ver la pantalla. Con más de dos las personas, se sugiere
usar un proyector de modo que todos los participantes pueden ver lo que se está haciendo.
Existen dos roles en este juego: programador y soporte. Cada persona se turna para ser el
programador, mientras que todos los demás toman el papel de soporte.

1. El programador dice la función que va a escribir. Se sugiere algo pequeño que se

pueda completar en menos de 5 minutos.

2. Cuando el programador ha finalizado, él informa que ya ha terminado.

3. Cada soporte califica la función de 0 a 10, 10 es el valor más alto y 0 el más bajo. Por
cada punto menor de 10, el soporte debe recomendar alguna forma para que sea 10.
a. El soporte después que dé su calificación, dice como quiere que el código se escriba.
b. El soporte manifiesta lo que haría para conseguir un 10.

4. Uno de los soportes toma el papel de programador, y el proceso comienza de nuevo.

5. Después que todos han tenido un turno de ser programador, puede repetir el ciclo,
pero esta vez el programador comienza con el código que él o ella escribió antes y
trata de mejorarlo por un par de minutos para levantar la calificación.
Ejemplo
Aquí está un turno del ejemplo entre dos de los programadores en nuestro equipo Javier y
Norma.

1
 Javier: Yo comienzo. Voy a escribir una función que incrementa una variable
privada hasta que alcanza cierto valor y entonces lo reinicio.

Norma: De acuerdo.

<Javier digita lo siguiente>

class JuegoPar {
int var;

public void Incrementar()

{
var++;
if (var > 500)
{
var = 0;
}
}
}

Javier: ¡He terminado!

Norma: Le doy un 5 de 10. Me gusta, por ser conciso, por el nombre de la clase,
porque el método es claro y el código es fácil de leer. Para conseguir 10,
el nombre de la variable de enteros debería ser significativo; var no
significa mucho para mí. La variable de enteros se debe inicializar en
alguna parte. Los números límite y reinicio, 500 y 0, deben ser variables o
constantes para facilitar las modificaciones. Usted debería escribir una
prueba para probarlo. Si tiene todo lo expuesto le doy una calificación de
10 sobre 10.

Javier: Gracias, Norma.

Norma: De nada. Ahora es mi turno.

indicaciones para los soportes
• Utilice realimentación positiva. Diga que hacer para llegar a 10. No diga que lo
que no le gusta.
• No sea personal. Mantenga sus comentarios enfocados al producto, no al
programador. Es mejor decir, "me gusta la forma que la función usa el operador
de incremento" antes que "me gusta de la forma como usas el operador de
incremento"
• Recuerde que se está calificando el producto no al programador
Indicaciones para el programador
• Recuerde, no es personal. El soporte está calificando el código, no a Ud.

2
 • Recuerde agradecer siempre al soporte por las observaciones. Esto ayuda a
mejorar el producto.

EJERCICIO DOS
ejercicio paso a paso para sentir la programación extrema
En este ejercicio, usted se enfoca la programación extrema y no se preocupe por las
otras prácticas. El objetivo es ayudar a los dos (programador y soporte), como escribir
código como un par.
Para hacer este ejercicio, se necesita una computadora personal con un teclado, un
ratón, las herramientas de desarrollo.NET Framework instaladas, dos sillas, suficiente
espacio para que los desarrolladores puedan sentarse delante de la computadora
personal y ver la pantalla, y una copia de este ejercicio.
Comience con uno controlando la computadora (el conductor) y el otro con una copia del
ejercicio (el navegador). El navegador va a guiar al conductor a desarrollar el código. En
ciertos puntos se cambiarán los papeles. Es importante turnar en el momento no
después. Mientras está en el papel de navegador, trate de no mostrar a su socio el código
escrito del ejercicio. Debe intentar comunicar verbalmente lo que se necesite hacer.
Puede dibujar diagramas y como último recurso lee la línea de código para teclearse. Si
en cualquier punto se siente inseguro de lo que ha hecho, es hora de compilar y probar.
Usted debe ser capaz de compilar y correr el programa después de cada paso.
Siguiendo con el tema, va a desarrollar un protector de pantalla (screen saver) competo:
según el código del archivo “02 Pair programming.pdf”, “Exercise 2-2: Step-by-Step
Exercise to Get a Feel for Pair Programming”, pagina 5.

1. Cree un nuevo proyecto “Aplicación de windows forms” llamado ExtremeScreenSaver.

2. Cambie el nombre de la clase “Form.cs” a “SaverForm.cs”.

3. Edite el constructor para recibir in parámetro entero y almacenarlo en el miembro de

la clase ScreenID. Para ello click botón derecho en SaverForm.cs del explorador de
soluciones y clic ver código.
private int screenID;
public SaverForm(int screen)
{
InitializeComponent();
screenID = screen;
}

4. Edite el método Main para que use parámetros. Para que Windows lance un protector
de pantalla. Puede ayudar si hace un dibujo para su socio (en una pizarra o un pedazo
de papel).
Argumento Significado
/c Muestra la configuración de la pantalla

3
 /s Activa el protector de pantalla
/p Realiza una pre visualización del protector de pantalla
static void Main(string[] args)
{
if (args.Length > 0)
{
// config
if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{ }
// saver
else if (args[0].ToLower() == "/s")
{ }
// preview
else if (args[0].ToLower() == "/p")
{ }
}
else
{ }
}

5. Cree un método interno estático en la clase de SaverForm llamada LaunchSaver,

añada el código para iterar a través de todas las pantallas conectadas a la PC y cree
un nuevo formulario para correr en esa pantalla.
static internal void LaunchSaver()
{
for (int i = Screen.AllScreens.GetLowerBound(0);
i <= Screen.AllScreens.GetUpperBound(0); i++)
{
System.Windows.Forms.Application.Run(new SaverForm(i));
}
}

6. Regrese al método Main, invoque a este método con los argumentos por defecto.
static void Main(string[] args)
{
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{ }
else if (args[0].ToLower() == "/s")
{
SaverForm.LaunchSaver();
}
else if (args[0].ToLower() == "/p")
{ }

4
 }
else
{
SaverForm.LaunchSaver();
}
}

7. Compile y corra el programa. Ciérrelo, y entonces renombre la extensión de EXE a

SCR. Usted debe ser capaz de instalarlo y correrlo como un protector de pantalla.

8. Cambie los roles.

9. Configure para que ocupe toda la pantalla, responda al mouse y los eventos del
teclado para cerrarlo. En la vista de diseño de SaverForm, configura la propiedad de
FormBorderStyle en None.

10. Cree un manejador de eventos para el evento Load del formulario. Haga doble clic
sobre el formulario en la vista de diseño. En este método ponga los límites de la
pantalla, oculte el cursor y muestre el formulario encima de los otros formularios.
private void SaverForm_Load(object sender, System.EventArgs e)
{
Bounds = Screen.AllScreens[screenID].Bounds;
Cursor.Hide();
TopMost = true;
}

11. En este método Load, se puede añadir el código del manejador de eventos del ratón
y del teclado. Se quiere manejar esos eventos para decidir cuándo finalizar la
ejecución del protector de pantalla. Se comienza añadiendo el manejador de eventos
del ratón, llamado SaverForm_MouseEvent. En Visual Studio.NET, al digitar
MouseMove += y presionar la tecla TAB se genera el esqueleto del manejador.
private void SaverForm_Load(object sender, System.EventArgs e)
{
...
MouseMove +=new MouseEventHandler(SaverForm_MouseEvent);
}
Cuando la aplicación corre por primera vez, la ubicación del ratón se obtendrá a través
el evento de movimiento del mouse, así la primera vez sólo necesitamos capturar la
posición del mouse en una variable miembro. Después de eso, si se mueve el mouse
se cerrará la aplicación.
private Point initialMousePt;
private void SaverForm_MouseEvent(object sender, MouseEventArgs e)
{
if (!initialMousePt.IsEmpty)
{
if (initialMousePt != new Point(e.X, e.Y))

5
 Close();
}
initialMousePt = new Point(e.X, e.Y);
}

12. Se puede usar este mismo manejador de evento para el evento mouse down que
ocurre cuando el usuario hace clic. Añádalo en el método load. Luego cambie el
método MouseEvent para cerrar el protector de pantalla cuando se haga un clic.
private void SaverForm_Load(object sender,
System.EventArgs e)
{
...
MouseMove +=new MouseEventHandler(SaverForm_MouseEvent);
MouseDown +=new MouseEventHandler(SaverForm_MouseEvent);
}

private void SaverForm_MouseEvent(object sender,

MouseEventArgs e)
{
if (!initialMousePt.IsEmpty)
{
if (initialMousePt != new Point(e.X, e.Y))
Close();
if (e.Clicks > 0)
Close();
}
initialMousePt = new Point(e.X, e.Y);
}

13. Se hará lo mismo para el manejador del evento KeyDown.

private void SaverForm_Load(object sender,
System.EventArgs e)
{
...

KeyDown +=new KeyEventHandler(SaverForm_KeyDown);

}

private void SaverForm_KeyDown(object sender,

KeyEventArgs e)
{
Close();
}

6
14. Compile y corra el programa. Comienza a trabajar como un protector de pantalla.
Renombre la extensión de EXE a SCR. Ahora se tiene un protector de pantalla básico.

15. Cambie de roles.

16. Añada cierta funcionalidad de dibujo al protector de pantalla. Primero añada un

manejador de eventos Paint para la clase Form. Una vez más añada esta línea en el
método Load.
private void SaverForm_Load(object sender, System.EventArgs e)
{
...
Paint +=new PaintEventHandler(SaverForm_Paint);
}

private void SaverForm_Paint(object sender, PaintEventArgs e)

{
}

17. En el método para el evento Paint, añada código para dibujar el texto “eXtreme .NET”
en el centro de la pantalla. Use el método TranslateTransform para desplazar el texto
al centro de la pantalla.
Añada el namespace System.Drawing.Drawing2D a esta clase, esto es necesario para
usar el tipo enumerado MatrixOrder. La línea a añadir en el lugar de los using es:
using System.Drawing.Drawing2D;

private void SaverForm_Paint(object sender, PaintEventArgs e)

{
Graphics gc = e.Graphics;
Point screenCenter = new Point(
(int)(gc.VisibleClipBounds.Width/2),
(int)(gc.VisibleClipBounds.Height/2));

gc.TranslateTransform(screenCenter.X, screenCenter.Y, MatrixOrder.Append);

int fntSize = 12;

Font fnt = new Font(FontFamily.GenericSansSerif,fntSize);
Brush brsh = Brushes.Red;
StringFormat format = new
StringFormat(StringFormat.GenericTypographic);
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;

SizeF size = gc.MeasureString("eXtreme .NET", fnt);

7
 RectangleF rect = new RectangleF(
0 - size.Width/2,
0 - size.Height/2,
size.Width,
size.Height);

gc.DrawString("eXtreme .NET", fnt, brsh, rect, format);

}

18. Añada el control Timer al formulario (debe estar en el modo diseño) y use el evento
timer para volver a dibujar la pantalla de modo que se pueda obtener cierta animación
de texto. El control Timer se puede arrastrar de la caja de herramientas al formulario
y luego hacer doble clic sobre el Timer para generar el método que manejara el evento.
Asegúrese que la propiedad Enabled del Timer este en true para lanzar los eventos.

19. En el manejador del evento Timer, llame Invalidate.

private void timer1_Tick(object sender,
System.EventArgs e)
{
Invalidate();
}

20. Anime el texto. El texto crece y disminuye en la pantalla usando el método

ScaleTransform. Para hacer esto, se necesita variables miembro de la clase para la
escala actual y el cambio de escala. Se puede manipular éstos en el evento Tick del
Timer.
private float scale = 1;
private float scaleChange = 0.1F;

private void SaverForm_Paint(object sender,

PaintEventArgs e)
{
Graphics gc = e.Graphics;
Point screenCenter = new Point(
(int)(gc.VisibleClipBounds.Width/2),
(int)(gc.VisibleClipBounds.Height/2));

gc.ScaleTransform(scale,
scale, MatrixOrder.Append);
gc.TranslateTransform(screenCenter.X,
screenCenter.Y,
MatrixOrder.Append);
...
}

8
 private void timer1_Tick(object sender,
System.EventArgs e)
{
scale+= scaleChange;
if (scale < 1)
{
scaleChange = 0.1F;
}
if (scale > 20)
{
scaleChange = -0.1F;
}
Invalidate();
}

21. Compile y corra el programa. Puede disminuir el valor de la propiedad de Interval del
Timer para hacer una animación más visible.

22. Cambie de roles.

23. Use el modulo para manejar la memoria intermedia del Framework .NET para quitar
el parpadeo. Añada algunos movimientos de texto. Antes de añadir la memoria
intermedia a la clase Form, necesita configurar el formulario para usar el estilo
WMPaint, el estilo UserPaint y el estilo DoubleBuffer.
public SaverForm(int screen)
{
InitializeComponent();
screenID = screen;
this.SetStyle(
ControlStyles.AllPaintingInWmPaint|
ControlStyles.UserPaint|
ControlStyles.DoubleBuffer, true);
}

24. Añada la rotación de texto de modo que al girar crezca y se encoja. Para ello usara
dos variables miembros para el ángulo actual del texto y los grados que de cambiar el
Angulo. Puede modificar el método del evento Tick del Timer. En el método del evento
Paint se usa el método RotateTransform para rotar el texto alrededor de su origen.
private float angle = 0;
private float angleChange = 5;

private void SaverForm_Paint(object sender,

PaintEventArgs e)
{

9
 Graphics gc = e.Graphics;

Point screenCenter = new Point(

(int)(gc.VisibleClipBounds.Width/2),
(int)(gc.VisibleClipBounds.Height/2));

gc.RotateTransform(angle, MatrixOrder.Append);
gc.ScaleTransform(scale,
scale, MatrixOrder.Append);
...
}

private void timer1_Tick(object sender,

System.EventArgs e)
{
angle+=angleChange;
scale+= scaleChange;
if (scale < 1)
{
scaleChange = 0.1F;
angleChange = 5F;
}
if (scale > 20)
{
scaleChange = -0.1F;
angleChange = -5F;
}
Invalidate();
}

25. Compile y corra el programa. La animación podría parecer muy lento. Pruébelo como
protector de pantalla, renombrando la extensión de EXE a SCR.

Este ejercicio provee la comprensión de con qué frecuencia se debe cambiar los papeles y
cuán importante es para ambos que cada uno se involucre con el código que se está
desarrollando. La programación por pares no es divertida si usted está mirando escribir
código a otra persona. Asimismo, tiene muy poco valor si esto ocurre durante una sesión
de programación por pares.
En la programación por pares ambos desarrolladores deberían estar enfocados en la tarea
y ambos orientados a mejorar el código.

10
 EJERCICIO TRES
Ejercicios para que dos desarrolladores trabajen juntos
Las tareas siguientes son para que pueda trabajar junto con su socio y trate de desarrollar
las ampliaciones del protector de pantalla. Durante el ejercicio, asegúrese que usted cambie
los roles a menudo; se sugiere cambiar cada diez minutos.

1. Amplié el protector de pantalla para mostrar la vista previa.

En el ejercicio anterior, ha creado un punto de entrada al código que llamará cuando
se corra el programa con el argumento de /p. Amplié el código para dibujar la
animación en la ventana de vista previa del proyecto.
Indico: El segundo argumento de línea de comandos es un manejador de ventana
(hWnd) en el cual se debe dibujar la vista previa del protector de pantalla.

2. Amplié el protector de pantalla para mostrar la configuración del protector de pantalla.

Añada la funcionalidad para mostrar una caja de diálogo con la configuración, de modo
que el usuario pueda alterar la configuración del protector de pantalla. El punto de
entrada ya sido creado en el método Main cuando el parámetro de /c es pasado a la
aplicación.
Las configuraciones que pueden a ser alteradas son la velocidad de animación, el
Angulo de rotación, el color del texto y finalmente las especificaciones del texto.

11