Hasta ahora ehemos construido una lista de historias de usuario sobre el proyecto (es lo que se conoce como backlog). Validar un requisito es comprobar que es útil y "no basta con que suene razonable".
¿Por qué todo este lío? Porque un requisito puede sonar razonable y sin embargo no ser verificable. Si descubrimos el fallo en producción, arreglarlo nos saldrá muy caro. Recordad lo que vimos en la sesión 1.
Así que ¿cómo se valida un requisito? Con los cuatro rasgos siguientes
Por cada uno, decidid qué rasgo falla: verificabilidad, consistencia, completitud o trazabilidad. Después, reescribidlo para que lo cumpla.
get) en menos de 50 ms.
set) en menos de 200 ms.
set, get,
delete) debe
tener una prueba automatizada en la tubería de integración
continua.
Buscad el requisito que un cliente real no entendería, y el que ningún test podría comprobar.
"Adding manpower to a late software project makes it later."
A mitad de un proyecto retrasado, quien se incorpora necesita formación. Alguien del equipo tiene que dársela, y ese tiempo se resta del proyecto. El efecto es negativo antes de ser positivo.
La alternativa no es forzar el ritmo a base de gente. Es estimar y planificar bien desde el principio. Así no se llega tarde.
La Estructura de Descomposición del Trabajo descompone el proyecto en tareas cada vez más pequeñas, hasta que cada una se puede estimar por separado.
¿Por qué importa? Un bloque como «Fase 1 del proyecto» es demasiado grande para estimar bien. Hay que partirlo antes de ponerle un número.
¿Cómo se hace? Se deja de descomponer cuando una tarea cabe en uno o dos días de trabajo. Ni antes: sería demasiado grande para estimar bien. Ni después: sería demasiado detalle para que compense.
key,value)
set(key, value):
añadir al fichero,
como en la sesión 2
get(key):
escaneo lineal, sin índice
dict clave →
posición,
vuestra propuesta de la sesión 3)
rebuild_index()
al arrancar, como ya visteis
Todas reparten mejor o peor el riesgo de equivocarse. Vamos a ver las cinco, y hoy vais a practicar la última.
Una persona con experiencia da una cifra basándose en su criterio, sin ningún cálculo detrás.
Ejemplo: alguien que ya ha construido un índice hash antes mira la tarea «diseñar el índice en memoria» y dice: dos días.
Es rápida, pero depende por completo del criterio de una sola persona.
Se compara la tarea nueva con otra ya hecha y conocida, y se usa su coste real como referencia.
Ejemplo: implementar
rebuild_index() se
parece a implementar
get() — los dos
recorren el fichero línea a línea. Si
get() costó un
día,
rebuild_index()
debería costar algo parecido.
Solo funciona si existe de verdad una tarea comparable ya terminada.
Varias personas estiman por separado, sin conocer la respuesta de las demás, y repiten rondas hasta converger.
Ejemplo: cada persona del equipo escribe en un papel cuánto
costará implementar
rebuild_index(),
sin enseñarlo. Se recogen los números, se discuten los extremos
sin decir quién dijo qué, y se estima otra vez.
Así ninguna opinión dicha en voz alta arrastra a las demás.
En vez de una sola cifra, se dan tres: la optimista, la más probable y la pesimista. Se combinan en un número ponderado.
E = (optimista + 4 × más probable + pesimista) / 6
Ejemplo: implementar el analizador SQL — 3 días optimista, 5 más probable, 10 pesimista. E = (3 + 4×5 + 10) / 6 ≈ 5,5 días.
Pesa el escenario más probable sin ignorar los extremos.
Un punto de historia no mide horas ni días. Mide el tamaño o la complejidad de una historia, comparada con otras historias que el mismo equipo ya ha estimado.
¿Por qué importa? La gente estima mal en tiempo absoluto (¿cuántas horas?), pero compara bien en términos relativos (¿es más grande o más pequeña que esta otra?). Dos historias con el mismo número de puntos deberían costar un esfuerzo parecido, aunque el esfuerzo real en horas todavía no se conozca.
Ejemplo: si «implementar
get()» costó 3
puntos, una historia que se siente igual de grande también vale 3 —
no importa si al final tardó cuatro horas o seis. Los puntos no se
convierten en tiempo real hasta que el equipo mide su propia
velocidad, la última pieza del bloque de hoy.
Cada persona estima en privado. Todas las cartas se enseñan a la vez. Así ninguna cifra dicha en voz alta condiciona a las demás.
No nace de la nada: simplifica el método Delphi que acabáis de ver (Grenning, 2002; popularizado por Cohn, 2005), con cartas que se enseñan a la vez en vez de rondas escritas — pensado para equipos ágiles sin tiempo para tantas vueltas.
Los números de la baraja no son consecutivos. La distancia entre ellos crece a medida que crecen los números: de 1 a 2, de 2 a 3, de 3 a 5, de 5 a 8, de 8 a 13.
¿Por qué importa? Cuanto más grande es una tarea, menos sentido tiene fingir precisión. La diferencia entre 2 y 3 puede ser real. La diferencia entre 13 y 14 no lo es — nadie puede estimar una tarea grande con ese detalle. Una escala lineal (1, 2, 3, 4, 5…) invita a debatir diferencias que no existen.
Esta progresión se aproxima a la sucesión de Fibonacci (cada número, la suma de los dos anteriores) — aproxima, no exacta: 20 y 40 sustituyen a los 21 y 34 que tocarían, para que las cartas sean más fáciles de leer. No es la única escala posible: otras barajas usan potencias de dos (1, 2, 4, 8, 16) o tallas de camiseta (XS, S, M, L, XL). La idea de fondo es siempre la misma — hueco pequeño donde aún cabe precisión real, hueco grande donde ya no cabe.
Elegid cuatro o cinco historias ya reescritas. Estimadlas en equipo. Guardad los números: son vuestro primer registro de estimación.
La velocidad del equipo es cuántos puntos de historia completa, de media, en una iteración.
¿Por qué importa? Permite prever cuánto trabajo cabe en la siguiente iteración, a partir de datos reales, no adivinando cada vez.
¿Cómo se hace hoy? Todavía no habéis completado ninguna iteración. La de hoy es una velocidad inicial estimada. Se corrige con los datos de la primera iteración real.
Una iteración es un bloque de trabajo de duración fija, con un objetivo claro: entregas pequeñas y frecuentes, en vez de todo junto al final.
Después del descanso, esa cadencia sois vosotros programando en laboratorio.
Si vuestro equipo ya tiene código, contadlo: qué hicisteis primero, qué os costó más.
Una confirmación convencional sigue un formato fijo:
type: description.
El tipo dice qué clase de cambio es.
¿Por qué importa? Un historial con mensajes como «cambios» o «arreglo2» no dice nada. Con un formato fijo, cualquiera —incluido vuestro propio equipo dentro de un mes— puede leer el historial y saber qué pasó, sin abrir cada commit.
feat: add append-only set/get for user preferences
test: add unit tests for set/get (AAA pattern)
chore: configure CI pipeline for pytest
Ya son tres tareas de vuestra propia descomposición de esta mañana — el resto sigue el mismo patrón.
Seguid vuestra descomposición de tareas de hoy, una por una. Cada
commit, con su tipo:
feat,
fix,
test,
chore.