Plantillas…¿para qué sirven?

Escribo esta entrada tras observar una interesante actitud en nuestra profesión, aunque por otro lado no es nueva, sino que es tan antigua como dicha profesión. La verdad es que la tenía medio escrita hace ya días, y como llevo un buen lapso sin tener un minuto libre, creo que ya es el momento de sacar esta entrada a la luz.

Por un lado, desde el área de calidad yo preparo con cariño la metodología para cada proyecto:
– Adapto los procesos y herramientas.
– Adapto las plantillas al entorno, cliente, tecnología…
– Adapto el número de plantillas y procesos a cubrir al tamaño del proyecto y sus requerimientos de rigor, etc.
– Finalmente, intento detectar gaps que me indiquen que se trabaja más de la cuenta, y no se aporta valor al proyecto o a la empresa. El objetivo es hacer lo mínimo indispensable, y buscando siempre que nada se haga dos veces en dos sitios distintos.
– Luego con el día a día, compruebo si los proyectos necesitan algo (de más, o de menos).

Dicho esto, puedo encontrarme con la siguiente situación: para comunicar algo, alguien del proyecto manda un correo al cliente usando como adjunto un word en blanco (y unas frases escritas en él, sin ningún formato, logo ni orden prefijado).

Cuando lo reviso, realmente me pregunto porqué no se usó la plantilla que yo con tanto esfuerzo había preparado. Y no es porque me haya costado tiempo. En esta profesión, desde que se es programador, hay que aprender a que el trabajo (código o lo que sea) no es nuestro. No hay que tener el apego que se tiene a una obra de arte o a un hijo nuestro. Si hay que rehacerlo, o si hay que aplicar un cambio, se acepta. Eso no significa que lo hagamos con desgana ni sin cariño. Significa que hay que aceptar esos cambios igual que se acepta que un hijo tomará su propio rumbo lejos de nosotros algún día.

Volviendo al tema, a que si recibiéramos un documento de una empresa o del gobierno, nos gustaría que dicho documento no estuviera en blanco…sino que tuviera un formato…un logo identificando al organismo o empresa que nos lo envía…Sin embargo, cuando se trata de mandar al cliente un documento…¿porqué no usar una plantilla si ésta se encuentra ya disponible? ¿No da su uso una imagen de profesionalidad, coherencia y buen hacer?

¿No tiene el código su estilo, tabulaciones, estructura y formato? ¿Porqué no hacer lo mismo en lo único que va a ver el cliente (los documentos)? ¿No es cada día más común el usar patrones y estructuras de código estándares y que de esta forma nos aceleren el desarrollo?

Yo creo que el problema está en nuestra percepción de la diferencia entre el código y los documentos. El código lo vemos como algo que es para nosotros, y por eso le dedicamos más tiempo y atención. Sin embargo, la documentación nos es ajena: es algo para el jefe, o para el cliente.

Y aquí, en mi opinión, es cuando pecamos de no aplicarnos lo que exigimos a los demás. El código que nos pasan los compañeros nos gusta que esté estructurado y cumpla un estándar, si es posible, coherente y común en todo el proyecto. Pero no sentimos la misma obligación de seguir un estándar a la hora de por ejemplo usar un documento de cara al cliente.

Hay otro problema añadido con los documentos, y es que tienen la habilidad pasmosa de salirse de contexto. Un word adjunto a un correo, tiene sentido. Pero cuando alguien lo copia y pega en otro correo…o lo guarda en una carpeta de red…ya hemos perdido el contexto. Perdemos el autor, la fecha, la empresa…(oh, claro, tenemos las propiedades del documento, que ni son obvias ni fáciles de ver, aparte de que no demuestran un autor, sino la máquina desde la que se creó).

¿Y tú? ¿Eres de los que prefieres usar un documento en blanco aún cuando existan plantillas para algo? ¿O prefieres inventar la rueda una y otra vez excusándote en la creatividad?

Toma de Requisitos – Paso 9: Requisitos no funcionales

Toma de Requisitos – Paso 9: Requisitos no funcionales

Hoy vamos a  finalizar esta serie de artículos sobre la toma de requisitos (algunos suspiraréis de alivio), explicando el último paso: la documentación de requisitos no funcionales.
Esta entrada forma parte de una serie cuyo índice es el siguiente:
  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

Una vez tenemos cerrado el prototipo, es importante cerrar la documentación de usuario (que representa sobre todo los requisitos de interfaz), pero también, es vital complementarlo con los requisitos no funcionales.

Las tareas realizadas en los Pasos 1 a 8 nos han permitido solventar proyectos basados principalmente en interfaz, proyectos más bien pequeños.

Sin embargo, siempre tendremos funcionalidades necesarias pero difíciles de plasmar en un prototipo o en un manual de usuario: los requisitos no funcionales. Aquí podemos encontrar entre otros:

  • Velocidad de acceso a la aplicación, o tiempos de respuesta.
  • Uso de memoria.
  • Interfaz con el sistema operativo o con otros sistemas (tanto hardware como software).
  • Algoritmos detallados con reglas internas de comportamiento (reglas de negocio).

¿Hay que hacer un documento con todo esto? Pues no del todo. Lo que hay que hacer es recopilar esta información para que no se pierda, y esto puede hacerse en varios sitios (seamos ágiles):

  • Como un anexo del manual de usuario
  • Como notas en una pizarra o post-its en la pared (que alguien se acuerde de hacerle una foto, antes de que se los lleve el viento!!)
  • Etc.

Finalmente, viene la parte más dura: hay que revisar, establecer una línea base, y poner bajo control de cambios este documento/foto/pizarra.

  • Revisar: siempre viene bien, 4 ojos ven más que 2. Si programar entre pares produce buen código…¿porqué no revisar más de una persona los documentos?
  • Línea base: hay que dejar claro un punto de partida. Difícilmente sabremos llegar a ningún sitio si no tenemos claro cuál era nuestro punto de origen.
  • Control de cambios. No pongáis la cara que suelen poner la gente en mis proyectos cuando les cuento esto. Control de cambios podría ser hacer una foto nueva a la pizarra cada vez que cambiamos los post-it, o guardar el documento en subversion y guardar una nueva versión cada vez que lo modificamos.

Y esto ha sido todo. Para finalizar, decir que estos 9 puntos no indican COMO ha de ser una toma de requisitos. Es tan sólo una aproximación para hacerlo, orientada a proyectos en los que sea primordial contar con un prototipo, exista un cliente involcurado, predominen los requisitos funcionales sobre otros, etc.

Como ya creo haber comentado en algún otro post anterior, estaría relacionado con la metodología UIDD (o User Interface Driven Development), donde lo primero que se hace es la interfaz, y se va propagando el desarrollo a otras capas o partes del sistema. Ojo, no significa esto que la interfaz esté cerrada. Recordad que la realidad siempre estará en contra nuestra, y lo más probable que cambie…sea lo más estable y asentado que tengamos. Gracias Sr. Murphy por tu ley.

Toma de Requisitos – Paso 8: Escribir documentacion de usuario

Toma de Requisitos – Paso 8: Escribir documentación de usuario

Hoy vamos a continuar explicando los pasos necesarios para una toma de requisitos, con el paso nº 8: escribiendo una documentación de usuario detallada, basada en el prototipo que completamos enel paso 6 y que establecimos en el paso 7 como línea base de los requisitos.

Esta entrada forma parte de una serie:

  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

Una vez tenemos cerrado el prototipo, es importante cerrar también, lo antes posible, una documentación de usuario (requisitos, manual de usuario, etc).

Muchos pensaréis: “venga ya. ¿ahora vamos a documentar? ¿No basta con el código?”. De esto ya hemos hablado en otros posts: “Nos gusta programar pero no documentar“. Hay varios motivos para hacerlo:

  • Porque lo pide el cliente (sí, en multitud de pliegos, concursos públicos, etc., se exige documentación).
  • Porque lo necesita el cliente (sí, de nuevo, los manuales se necesitan, como se necesita una rueda de repuesto. Y eso es así, aunque la rueda de repuesto, al igual que el manual, quizá no se lleguen a usar).
  • Porque el cliente no se va a leer tu código cuando tenga que hacer algo y no sepa cómo, o cuando algo no funcione como el usuario cree que debe hacerlo.
  • Porque cada vez que el cliente quiere negociar o revisar el avance del proyecto, no se va a leer tu código para ver cómo va a funcionar todo cuando esté: lo que se revisa son los requisitos o un manual provisional.

Bueno. Sigamos. Aunque normalmente se documenta al final, en nuestra aproximación, lo haremos al principio. ¿Porqué? Pues porque estamos haciendo una toma de requisitos, y la mejor forma de hacerlo es dejando los documentos por adelantado.

Es más fácil para el equipo de desarrollo consultar el manual a la hora de hacer unas pruebas, o de avanzar el desarrollo, que cualquier otra cosa. Quizá el usuario no se lea el manual, pero al menos los programadores y los testers sí deberían estar hartos de leerlo. Probablemente el usuario no se lo lee porque los manuales que solemos hacer son siempre “fuera de hora”: los hacemos en ese tiempo que hay al final del proyecto, y porque nos obligan, y siempre es en horas muertas, o cuando ya estamos reventados de intentar sacar adelante una funcionalidad que ya va retrasada. Por cierto, esa funcionalidad tal vez no estaría retrasada si no hubiéramos tenido que rehacer 20 veces el producto…y eso ocurría (tal vez), si nos hubiéramos molestado en hacer un manual de usuario al principio (como aquí planteo).

Otra ventaja de hacer la documentación y manuales al principio, evita tener que hacer una especificación técnica detallada. Ya se indica cómo debe funcionar todo, ya están los requisitos…¡pues a programar!

El cliente y usuarios finales entenderán mucho mejor un manual, y seguro que si es el mismo que usan (y revisan y corrigen) los programadores en el día a día, será un manual útil, y no el típico ladrillo que se suele hacer y que nadie lee.

El tener una documentación completa tan temprano, pule aún más posibles inconsistencias y puntos “oscuros” que pudieran haber quedado en nuestro prototipo. Se evitan muchas veces el tener documentos demasiado técnicos. En su lugar, se está haciendo una documentación basada en el uso, en la funcionalidad, no en la tecnología.

Este tipo de documentación, se va a mantener y a actualizar, mucho mejor que cualquier otro tipo de documento. Puesto que es algo que todo el mundo usa y necesita tenerlo al día: los usuarios finales, los programadores, los analistas, los testers…es como el anillo de la película del señor de los anillos: “un documento para unirlos a todos…”.

Este tipo de documento es práctico, sin rollos que pretendan artificialmente hacerlo ameno, o inteligente, o complejo. Dice lo que el usuario necesita que el software haga. Y punto.

En este documento, como hemos dicho, se especifica (como si fuera un documento funcional), el QUE, pero no el COMO.

Pero además, este tipo de documentación da a los programadores libertad y creatividad para resolver técnicamente las cosas como mejor les parezca. Y de esta forma, es mucho más fácil que acabe creando software que cumpla lo QUE necesita el usuario.

Un saludo.

Toma de Requisitos – Paso 7: Prototipo como Requisitos 1.0

Toma de Requisitos – Paso 7: Prototipo como Requisitos 1.0

Hoy vamos a continuar explicando los pasos necesarios para una toma de requisitos, con el paso nº 7: establecer el prototipo como la primera versión de los requisitos.

Esta entrada forma parte de una serie cuyo índice es el siguiente:
  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

Una vez llegados a este punto, tendremos un prototipo bastante completo. Pero…¿No se trataba de tomar los requisitos? ¡Pero si ya los tenemos! Basta con considerar el prototipo como la primera versión de los requisitos.

Para ello, el prototipo debe cumplir una serie de características:

  • Debe ser estable.
  • Debe haber un compromiso por parte del equipo de desarrollo de hacer el software realmente a imagen y semejanza del prototipo.
  • El cliente, o al menos los usuarios clave, han de validarlo.
  • Debe ponerse al prototipo bajo control de cambios. No podemos modificarlo a la ligera. Un cambio en el estilo, en el flujo, en la funcionalidad…nos puede provocar una tormenta imparable de cambios.

A partir de aquí, basaremos todo en el prototipo, de forma que sirva de base para crear:

  • Las estimaciones.
  • Los planes.
  • La estructura y organización del equipo.
  • Los diseños.
  • EL desglose del trabajo que permita construirlo.

Y aquí da igual la metodología que usemos. Sea ágil o no, hay que aceptar los cambios en el prototipo, como parte de los cambios que se requieren para el producto final.

El control de cambios no significa “ya está”, “ya lo tenemos y no hay que tocarlo”. Pero sí significa que tenemos que estar atentos a cada cambio, y realizar el adecuado seguimiento antes de aceptarlo, rechazarlo, o ponerlo “en espera”. Ya dedicaremos un día algún artículo más detallado al control de cambios, y algunos trucos al respecto que espero os sean útiles.

Por desgracia, la manera más común de tratar los cambios es aceptar todo sí o sí, desbaratando cualquier plan existente, y evitando realizar nuevos planes, que al final, pudieran habernos llevado al éxito. Por desgracia, es así en demasiadas ocasiones. Y es que nos ciega el éxito, nos da miedo involucrar al cliente y realmente llevar un buen control de cambios. En fin.

Una vez tenemos la primera línea base del prototipo, la primera versión por tanto de los requisitos, tendremos una serie de logros adicionales:

  • Posibilidad de empezar con la documentación de usuario (manuales, etc).
  • Preparar los planes de pruebas, con todo detalle.
  • En paralelo, también pueden comenzar la arquitectura, diseño y algunas tareas de implementación.

En el siguiente post de esta serie, veremos ya la creación de documentación, y la toma de requisitos no funcionales.

Un saludo.

Toma de Requisitos – Paso 6: Completar el prototipo

Hoy vamos a continuar explicando los pasos necesarios para una toma de requisitos, con el paso nº 6: completar el prototipo.

Esta entrada forma parte de una serie cuyo índice es el siguiente:
  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

Una vez hemos llegado a este punto, y tenemos una guía de estilo en condiciones, podremos pasar a completar el prototipo hasta hacerlo totalmente funcional.

Ojo, no estamos diciendo que el prototipo se acabe convirtiendo en la aplicación final. Esto ha sido ampliamente discutido en muchos foros, y tiene sus defensores (especialmente en el ámbito del software ágil) y sus detractores (especialmente desde el punto de vista de la ingeniería del software).

De esta forma, se consigue que los desarrolladores tengan una visión completa de lo que será el producto final. Hay dos visiones:

  • La visión del producto permite alinear el trabajo de los desarrolladores.
  • El prototipo detallado permite una visión mucho más detallada, facilitando a los desarrolladores el trabajo.

El prototipo, llegados a este punto, deberá ofrecer toda la funcionalidad del software, con al menos:

  • Todos los cuadros de diálogo, incluyendo los cuadros de diálogo estándar como Abrir, Cerrar, Imprimir, Guardar, etc.
  • Todas las pantallas de inserción de datos.
  • Todas las salidas de datos (pantallas, informes, listados…)
  • Todas las interacciones con el sistema operativo (ejemplo: importación y exportación al portapapeles).
  • Interacción con sistemas externos y otros productos de terceros.

El prototipo contendrá por tanto las principales interfaces:

  • Con el usuario
  • Con el sistema operativo
  • Con otros sistemas externos

Llegados a este punto, tendremos que hacer una línea base (no olvidemos la gestión de la configuración, que sea un prototipo-borrador no significa que debamos correr el riesgo de perderlo!!).

Tal y como establece Steve McConnell en su magnífico libro Software Project Survival Guide:

“No deberías usar un prototipo como la base de software real, así como no deberías usar un decorado de Hollywood como base para una casa de verdad”.

El prototipo es un callejón sin salida, útil, pero un callejón sin salida. No ha habido una arquitectura, no está preparado para construir sobre él la aplicación final. La mayoría de autores recomiendan construir el prototipo en un entorno y en un lenguaje de programación que facilite el desarrollo rápido, pero que claramente no vaya a usarse en el desarrollo final. Por ejemplo, úsese Visual Basic o un lenguaje similar de alto nivel, cuando el desarrollo final vaya a ser en Java o C++ o C#. Esto evitará tentaciones más adelante.

Toma de requisitos – Paso 5: Crear una guía de estilo

Hoy vamos a ver el paso 5º de la guía sobre toma de requisitos.
Esta entrada forma parte de una serie cuyo índice es el siguiente:
  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

Los usuarios han aceptado y validado el prototipo (sí, eso fue el Paso 4 anterior). Así que ahora, los programadores deberían crear una guía de estilo: un pequeño manual o guía que identifique los estándares de estilo a seguir durante el inminente desarrollo software.

A ver, que esto no es una metodología: no hacen falta 200 páginas. Ni 20. Seguramente, con un par de páginas será suficiente. Habrá que añadir:

  • Estilos visuales
  • Imágenes con las pantallas más representativas (los 2 o 3 tipos de pantallas o cuadros de diálogo a mostrar).
  • Ubicaciones de los botones, incluyendo los más habituales (Aceptar, Cancelar, etc).
  • Estilos visuales: efectos, colores, tipos de letra.
  • Mensajes de texto a mostrar. Se trata de buscar una terminología común, que todos los conceptos tengan un nombre único, usado de forma consistente en todas las pantallas, y sea un nombre familiar en el contexto del negocio del cliente.
  • Estándares existentes a los cuales nos vamos a adherir sobre todo a nivel de usabilidad y accesibilidad.

Por supuesto, tras completarla, deberá revisarse y hacer una línea base (ponerla bajo control de cambios). Para esto no hace falta nada del otro mundo: un subversión o un repositorio similar bastarán.

Los estilos visuales, cuanto antes sean definidos, más fácilmente lograrán que haya consistencia en la interfaz de usuario. Después de todo, los requisitos cambiarán. Pero el aspecto visual ,es un buen sitio por el que empezar como base.

Para finalizar, van algunos estándares o normas relacionadas con los interfaces:

  • ISO/IEC 9126: evaluación de productos software.
  • ISO 9241: requisitos ergonómicos para trabajar con terminales de presentación visual (VDT)
  • ISO/IEC 10741: interacción de diálogos.
  • ISO/IEC 11581: símbolos y funciones de los iconos.
  • ISO 11064: diseño ergonómico de centros de control.
  • ISO 13406: requisitos ergonómicos para trabajar con presentaciones visuales basadas en paneles planos.
  • ISO 13407: procesos de diseño centrados en la persona para sistemas interactivos.
  • Guías de estilo para la web: IBM, W3C

Toma de requisitos – Paso 4: Presentar el prototipo

Hola, hoy vamos a ver el paso siguiente (Paso nº 4 en nuestra secuencia) en la definición de los requisitos, y para ello, tendremos que presentar a los usuarios, el prototipo que con tanto mimo hemos creado.

Esta entrada forma parte de una serie cuyo índice es el siguiente:

  1. Identificación de usuarios finales clave.
  2. Entrevista a dichos usuarios finales.
  3. Construcción de un prototipo basado en los resultados de las entrevistas. Es importante que el prototipo sea a la vez simple e interactivo.
  4. Presentación del prototipo a los usuarios finales, solicitando feedback.
  5. Desarrollar una guía de estilo que refleje el diseño/interfaz del prototipo.
  6. Completar y extender el prototipo hasta que demuestre funcionalmente todo el software.
  7. Utilizar el prototipo como la primera línea de base de los requisitos.
  8. Escribir una documentación de usuario detallada, basada en el prototipo anterior.
  9. Crear documentación de requisitos no funcionales para algoritmos, procesos, interfaces con otros sistemas hardware y software, etc.

En primer lugar, hay que hacer notar que la primera versión de un prototipo difícilmente va a gustar a los usuarios. Es algo normal, sus expectativas no van a cubrirse en esta primera versión.

Lo que hay que buscar en realidad es el feedback de dichos usuarios clave: sus comentarios son oro. Y lo son, porque tan sólo cuando esos usuarios ven el prototipo, la maqueta de nuestra aplicación, es cuando van a darse cuenta de detalles que habían pasado por alto, de información que difícilmente podría ser obtenida de otra manera.

Por supuesto, a los usuarios hay que dejarles claro que es un prototipo: ni hemos tenido un avance del 40% del proyecto en dos días, ni los problemas que vayan a surgir en la revisión han de ser tenidos en cuenta. Hay que tranquilizar a los usuarios en este sentido: aún estamos muy lejos de cerrar el prototipo, y por tanto, aún más lejos de tener avanzado el desarrollo del producto.

Es en esta fase cuando tendremos que hacer un auténtico ejercicio de usabilidad: conseguir no sólo que los requisitos se satisfacen, que han sido correctamente identificados. Además de esto, el producto debe ser sencillo, lógico, fácil de usar.

Es importante notar que en esta fase, hay que estar volcado al 100%, y hay que tener experiencia en el área que estamos prototipando. Si no es así, ni va a ser sencillo de usar, ni tampoco va a satisfacer las necesidades de los usuarios.

El objetivo final de esta fase es conseguir el apoyo, la excitación de los usuarios al lograr consciencia de que efectivamente, hemos entendido sus necesidades, y además, el producto va a facilitarles el día a día. No se trata de “satisfacer requisitos”, sino más bien de satisfacer a los usuarios finales.

En esta fase, puede pensarse que se está perdiendo un tiempo precioso en algo que va a tirarse a la basura. Después de todo, ese es el final de todo prototipo. Nada más lejos de la realidad. Al contrario, todo el esfuerzo invertido facilitará y acelerará el desarrollo posterior, evitando problemas, revisiones, y cambios de última hora.

Como ya he comentado, es fundamental aclarar a los usuarios que el producto es un prototipo, un mero “esbozo” de la realidad que aún está por construir. Por eso, al final, vuelve a servir lo que comentaba en el artículo anterior, en el paso 3: las herramientas de prototipado simples como el Paint o PowerPoint, o un dibujo en un papel, son mucho más efectivas. Esto es así porque el usuario las percibe como algo realmente temporal, no aprovechable. Si nos liamos a hacer mucho código, HTML, css, JavaScript, menús desplegables, etc, etc el usuario pensará que lo que está probando es ya un producto real. Después de todo, se instala, se usa, y da resultados como un producto real. Si caemos en la trampa de dar un prototipo demasiado realista, el cliente pasará a meternos presión, ya que pensará que le estamos engañando, y que en realidad, tenemos ya avanzado buena parte del desarrollo.

Es importante dar también una fecha límite a la fase de revisión del prototipo: 2 o como máximo 3 revisiones de prototipo, deberían ser suficientes. Si nos alargamos en su revisión, sí que podremos poner en peligro el plan general del proyecto.

Si quieres volver al índice haz clic en: Índice.
También puedes ir al paso anterior de la toma de requisitos haciendo clic aquí: Paso anterior.