Metodología SCRUM (ScrumDN) -...

Memoria PFC .NET

Oscar Montesinos Marín

UOC-PFC, Consultor David Gañan Jiménez

20/09/2013

Metodología SCRUM (ScrumDN)

Metodología SCRUM (ScrumDN) Oscar Montesinos Marín UOC-PFC Invierno 2013

1

Contenido 0. Introducción .......................................................................................................................... 3

1. Justificación del proyecto ...................................................................................................... 4

a. ¿Por qué el proyecto? ....................................................................................................... 4

b. Descripción del proyecto ................................................................................................... 4

c. Objetivos del proyecto ...................................................................................................... 4

1. Generales .......................................................................................................................... 4

2. Específicos ......................................................................................................................... 5

d. Justificación tecnológica.................................................................................................... 5

e. Productos obtenidos ......................................................................................................... 5

f. Planificación inicial vs planificación final........................................................................... 6

2. Plan del proyecto .................................................................................................................. 7

a. Metodología del proyecto ................................................................................................. 7

b. Propuesta de Actividades y cronograma........................................................................... 7

Relación de actividades ................................................................................................. 7

Estimación de tiempos .................................................................................................. 8

Hitos a cumplir .............................................................................................................. 8

Diagrama de Gantt ........................................................................................................ 9

3. Análisis ................................................................................................................................. 10

a. Requerimientos de la solución ........................................................................................ 10

1. Funcionales ...................................................................................................................... 10

2. No funcionales ................................................................................................................. 10

b. Resultados esperados ..................................................................................................... 11

c. Organización del proyecto .............................................................................................. 11

a. Recursos SW/HW ........................................................................................................ 11

b. Arquitectura del proyecto ........................................................................................... 12

c. Tecnologías a utilizar ................................................................................................... 12

d. Análisis e identificación de riesgos potenciales en el proyecto ...................................... 12

4. Diseño .................................................................................................................................. 14

a. Diagrama de casos de uso ............................................................................................... 14

b. Modelo conceptual ......................................................................................................... 14

c. Diagramas de arquitectura .............................................................................................. 15

Software ...................................................................................................................... 15

Hardware ..................................................................................................................... 15


2

d. Diseño de la base de datos .............................................................................................. 16

e. Modelo de clases ............................................................................................................. 17

g. Diseño de la interfaz de usuario (Prototipo) ................................................................... 18

5. Implementación .................................................................................................................. 23

a. Decisiones de desarrollo. ................................................................................................ 23

b. Patrones utilizados. ......................................................................................................... 23

c. Dificultades en la implementación. ................................................................................. 24

d. Trabajo futuro. ................................................................................................................ 24

6. Memoria y presentación ..................................................................................................... 25

7. Conclusión ........................................................................................................................... 26

8. Bibliografía y enlaces ........................................................................................................... 27


3

0. Introducción

La realización del PFC (Proyecto Fin de Carrera) conlleva la elección de una propuesta de

proyecto a realizar por el estudiante, puede ser propia o seleccionado entre las propuestas

aportadas por el equipo docente. En este caso se ha seleccionado una de las propuestas

aportadas: Metodología SCRUM, a la que se le ha dado nombre clave: ScrumDN, para utilizarla

como nombre raíz del espacio de nombres en las distintas partes de la aplicación.

La selección de esta propuesta por parte del estudiante es debida al interés que suscita por

parte de la comunidad de desarrolladores, el uso de una metodología rápida, fácil de

entender, rápida, que interactúe con el cliente y con una documentación mínima (lo que se

engloba dentro de las llamadas metodologías agiles), como es SCRUM. Metodología que día a

día gana más adeptos y que es muy tenida en cuenta por los equipos de desarrollo de las

actuales empresas por su fácil adaptación y manejabilidad.

Para el alumno esta selección representa una oportunidad única de comprender, aprender y

desarrollar competencias propias de los estudios de la Ingeniería informática como son la

arquitectura, desarrollo, documentación y gestión de un proyecto de inicio a fin.

Competencias que en el caso de éxito sitúa al alumno en una posición inmejorable dentro de

su entorno laboral y con unos conocimientos mínimos necesarios para la divulgación técnica

dentro de su comunidad de usuarios de tecnologías .NET.


4

1. Justificación del proyecto

a. ¿Por qué el proyecto? La idoneidad del proyecto viene dada por la libertad de elección de la tecnología .NET

a usar. Esta libertad de tecnologías crea la oportunidad de implementar los

conocimientos adquiridos por el alumno en el último año para el desarrollo de

aplicaciones web multi-plataforma que se le ha exigido dentro de la empresa en la que

trabaja actualmente.

La empresa ha decidido utilizar la arquitectura DDD (Domain Design Driven/Diseño

Dirigido por el Dominio) para sus desarrollos futuros, una arquitectura que consiste en

construir los proyectos o aplicaciones desde los dominios o problemas, es decir la

lógica de negocio de la aplicación que se plantea desarrollar, aplicaciones que suelen

ser medianas o grandes.

Puede parecer que la aventura de construir una aplicación con la arquitectura

planteada (DDD), es una aventura muy complicada, que implica un riesgo temporal y

que aumenta la complejidad del sistema, pero para el parecer del alumno, este

proyecto es una oportunidad única para sentar las bases de un conocimiento que

podría potenciarle en su trabajo y poder divulgarlos dentro de la comunidad de

usuarios .NET a la que pertenece.

b. Descripción del proyecto El proyecto pretende gestionar los procesos necesarios para que una empresa pueda

seguir la metodología SCRUM en el desarrollo de sus productos de Software. Para ello

se creará una aplicación con una arquitectura orientada a dominio con tecnologías

.NET a la que se pueda conectar cualquier sistema front-end de una forma fácil y ligera.

Asimismo, el seguimiento del proyecto se hará desde otro gestor que permite hacer un

seguimiento de un proyecto mediante metodología SCRUM llamado Team Foundation

Service (TFS), que permite gestionar la creación de todo el proyecto, llevar un historial,

establecer roles, iteraciones, etc. El uso de TFS permitirá el conocimiento de las

características de la metodología SCRUM y además permitirá tener un repositorio de

código fuente para el control de versionado, recuperación de copias, y control del

estado de la aplicación.

c. Objetivos del proyecto Separamos los objetivos del proyecto en dos tipos: generales y específicos de lo que se

pretende crear.

1. Generales Investigar, estudiar y comprender la metodología SCRUM para gestionar el

desarrollo de proyectos de software.

Desarrollar una aplicación que gestione los procesos necesarios para seguir

la metodología SCRUM.


5

2. Específicos De investigación y estudio.

i. Buscar documentación sobre SCRUM que ayuden a la comprensión de

la metodología.

ii. Entender el funcionamiento de herramientas parecidas como Team

Foundation Service.

De gestión de proyectos con SCRUM.

iii. Creación de equipos y proyectos, pilas de producto, historias de

usuario (backlogs) e iteraciones.

iv. Gestión de los equipos de trabajo, creando roles dentro de cada

equipo: propietario del producto, maestro, desarrolladores y

asignación a tareas con control de horarios.

v. Creación y visualización de estadísticas de historia de usuarios y

proyectos.

d. Justificación tecnológica El aumento de dispositivos móviles en cualquiera de sus formatos y arquitecturas, crea

la necesidad de desarrollar nuevas aplicaciones que sean capaces de dar un servicio

adaptado al cualquier tamaño de pantalla así como rendimiento del dispositivo, es lo

que se llama hoy en día responsive design (diseño adaptativo).

Una de las soluciones que existen actualmente a este problema es la creación de un

back-end consistente que se pueda ser usado por clientes ligeros

HTML5+CSS+JavaScript o SilverLight de fácil implementación y que puedan utilizarse

dese cualquier plataforma ya sea por navegador o plug-in. Con una arquitectura DDD

sería posible crear este tipo de back-end, ayudado por tecnologías como ASP.NET o

Silverlight.

e. Productos obtenidos Se han obtenido los siguientes productos:

omontesinos_producto.zip

o Prototipo

Dentro del directorio prototipo se encuentra un prototipo de la aplicación

diseñada con SketchFlow en Silverlight que permite dar un vistazo al

diseño de la aplicación desde una navegador cualquiera. El prototipo se

ejecuta abriendo el fichero Default.html que se encuentra dentro del

directorio.

o ScrumDN

En este directorio se encuentran todos los fuentes de la aplicación que se

pueden abrir desde Visual Studio 2013 con la solución: ScrumDN.sln

o ScrumDN en http://scrumdn.azurewebsites.net

Se ha subido a Windows Azure la aplicación completa para poder probarla

libremente una vez autenticados con demo/123456.

omontesinos_presentacion.zip

o omontesinos_presentacion (carpeta con video)

http://scrumdn.azurewebsites.net/


6

Carpeta que contiene un video demostración de la aplicación en

formato MP4 (omontesinos_presentacion.mp4) que se puede

ejecutar directamente o visualizar desde un navegador accediendo

al fichero omontesinos_presentacion.html.

o Omontesinos_presentacion.pptx

Una sencilla presentación en Powerpoint de la aplicación.

omontesinos_memoria.docx

Este documento.

f. Planificación inicial vs planificación final La planificación inicial del proyecto presentaba muchísimos retos tecnológicos

importantes para la resolución del problema, los retos incrementaban su dificultad

debido al desconocimiento inicial de la metodología y la tecnología a usar para

desarrollar el planteamiento inicial

Ahora bien, una vez adquiridos conocimientos suficientes y empezado el proyecto con

Visual Studio 2012, Web API, y MVC4 se produjo un acontecimiento bastante

importante como fue la presentación el 13 de Noviembre del nuevo Visual Studio 2013

y la actualización de tecnologías Web API 2 y MVC5 así como la creación de

aplicaciones ASP.NET con seguridad integrada en una sola plantilla.

Pero no sólo eso, los cambios explicados por Scott Guthrie en su blog

http://weblogs.asp.net/scottgu/archive/2013/10/17/announcing-the-release-of-visual-

studio-2013-and-great-improvements-to-asp-net-and-entity-framework.aspx para el

trabajo con ficheros javascript y sobre todo angularjs creaban unas buenas

expectativas en el ahorro de trabajo en la realización del proyecto.

Y por ese motivo se tomó la decisión del cambio y se procedió a hacer el traslado de

todo lo que estaba hecho hasta ese momento al nuevo VS2013, cambiando el sistema

de autenticación Membership de ASP.NET a Identity, hecho que junto a las nuevas

tecnologías OWIN y los problemas conocidos de Cross-origin resource sharing (CORS)

provocaron un terrible retraso que impidió la implementación completa de la

aplicación para el día previsto: 16 de Diciembre.

A partir de este hecho se retrasó todo el proceso de implementación a la última

entrega, tomando decisiones drásticas como no realizar la parte de logging (grabación

de errores) o la parte de testeo de la aplicación y el dominio. En una aplicación real y

en producción, estás dos partes son indispensables para el control de errores y

mantenimiento de la misma.

http://weblogs.asp.net/scottgu/archive/2013/10/17/announcing-the-release-of-visual-studio-2013-and-great-improvements-to-asp-net-and-entity-framework.aspx

http://weblogs.asp.net/scottgu/archive/2013/10/17/announcing-the-release-of-visual-studio-2013-and-great-improvements-to-asp-net-and-entity-framework.aspx

http://en.wikipedia.org/wiki/Cross-origin_resource_sharing


7

2. Plan del proyecto

a. Metodología del proyecto Tal y como se ha comentado en un punto anterior la metodología a seguir en la

elaboración del proyecto va a ser SCRUM dentro de un proyecto de equipo en TFS que

servirá como plataforma de aprendizaje de implementación de la metodología a tratar

por el proyecto. Aunque en principio el usuario “Alumno” es el único miembro del

equipo, se podrá asignar una cuenta al consultor de la asignatura “propietario del

producto” para que pueda consultar en cualquier momento la evolución del proyecto.

b. Propuesta de Actividades y cronograma El PFC se compone de varias partes entregables separadas en 4 entregas y un debate

con una fecha pre-asignada. Dentro de cada entrega (PEC) tenemos las siguientes

actividades.

Relación de actividades

PEC 1

Plan del Proyecto

Planificación

Definición de la arquitectura

Riesgos

Análisis

Requerimientos funcionales

Requerimientos no funcionales

Documentación

PEC 2

Prototipo

Diseño de la interfaz gráfica

Diseño

Casos de uso

Modelo conceptual

Arquitectura

Diseño de la BD

Clases

PEC 3

Implementación

Se podrá ampliar el periodo de implementación a la entrega final

(memoria)


8

Manuales

Instalación

Uso

Memoria

Terminar implementación

Presentación

Video

Diapositivas

Estimación de tiempos

Actividad Duración

PEC 1 (Plan y análisis) 8 días

PEC 2 (Prototipo y diseño) 21 días

PEC 3 (Implementación y manuales) 34 días

Memoria final y presentación 83 días

Presentación 10 días

Debate virtual 1 día

Hitos a cumplir

Descripción Fecha hito

PEC 1 (Plan y análisis) 30/09/2013

PEC 2 (Prototipo y diseño) 28/10/2013

PEC 3 (Implementación y manuales) 16/12/2013

Memoria final y presentación 13/01/2014

Debate virtual 23/01/2014


9

Diagrama de Gantt


10

3. Análisis

a. Requerimientos de la solución

Se pretende construir una aplicación que permita seguir eficientemente la

metodología SCRUM para el desarrollo de proyectos de software. En esta sección se

describirán los pasos necesarios y requeridos por el enunciado del proyecto,

requerimientos funcionales que enumeran la características de la aplicación y no

funcionales pero necesarios para la aplicación.

1. Funcionales 1.1. Gestión de los desarrolladores y equipos de usuarios con definición de

roles.

Se crearán un registro usuarios y de equipos formados por los usuarios. El

este registro de usuarios se asignará un rol dentro del equipo como puede

ser: propietario del producto, maestro SCRUM o desarrollador.

1.2. Gestión de productos/proyectos software.

Creación de proyectos con descripción del proyecto y asignación de

usuarios y roles.

1.3. Creación de iteraciones, historias de usuarios y tareas.

Dentro de cada proyecto deberán crearse iteraciones, historias de

usuarios y creación de tareas con la posibilidad de asignación a usuarios y

horas de ejecución de cada tarea.

1.4. Asignación de roles.

Las funcionalidades definidas en los puntos anteriores serán gestionadas

por los mismos usuarios según el rol asignado, además el desarrollador

deberá indicar las horas dedicadas a cada tarea.

1.5. Visualización de estadísticas de historia de usuarios y proyectos.

Se deberán poder visualizar las estadísticas del estado del proyecto,

horas, tiempo que resta a la finalización de una iteración, tareas hechas,

tareas pendientes y tareas en ejecución.

2. No funcionales 2.1. Diseño adaptativo del GUI

La interfaz de la aplicación debe adaptarse a cualquier resolución para

que sea “usable” en cualquier dispositivo, ya sea tableta, portátil o equipo

de sobremesa.

2.2. Tiempos de respuesta adecuados.

La aplicación tiene que responder a las peticiones del usuario (consultas,

operaciones CRUD) de una forma rápida.

2.3. Seguridad en el acceso a la aplicación.

Tratándose de una aplicación web, deberán seguirse buenas prácticas de

seguridad para evitar ataques como XSS, SQL Injection, etc.


11

2.4. Control de errores para respuestas claras antes imprevistos.

Los errores que se muestren al usuario deben ser en un lenguaje

comprensible, claro y conciso del error o mensaje que queremos

transmitirle.

2.5. Control de calidad del software desarrollado.

Se habilitarán técnicas de análisis y control de calidad de código de

herramientas del mismo entorno de programación.

b. Resultados esperados

El resultado esperado en este proyecto es el de superar la realización del PFC con una

buena nota, aprender y adquirir experiencia necesaria para afrontar en el futuro

cualquier proyecto relacionado con las competencias adquiridas a lo largo de los

estudios de la Ingeniería Informática.

De estos resultados se crearán tres entregables:

Memoria

Documentación de la elaboración de todo el proyecto, objetivos propuestos,

consecución de los mismos, etc.

Producto

Aplicación, fuentes y documentación para su instalación y ejecución, así como

un manual de uso.

Presentación

Video de presentación del producto, diapositivas y síntesis del producto

realizado.

c. Organización del proyecto

a. Recursos SW/HW

Hardware

Pentium Dual-Core CPU E5800 3.20GHz con S.O. Windows 7 32bits 4GB

RAM.

Software

Team Foundation Service(TFS)/Visual Studio Online: Todo el control de

versiones del proyecto, así como tareas y funcionalidades a realizar,

errores, etc. se controlarán desde un proyecto dentro de TFS en una

cuenta particular del alumno, con la metodología SCRUM.

VS2013 Profesional: Se utilizará la edición Profesional de Visual Studio

2013 para el desarrollo de la aplicación que además permite la

automatización de los test unitarios y el control de calidad de código.


12

Blend para Visual Studio 2012: Herramienta que permite el diseño de un

prototipo mediante un proyecto de tipo SketchFlow.

b. Arquitectura del proyecto

La arquitectura del proyecto se basa en el libro de César de la Torre, Unai Zorrilla,

Javier Calvarro y Miguel Ángel Ramos: “Guía de Arquitectura N-Capas orientada al

Dominio con .NET 4.0”, que a su vez está basado en el afamado libro de Eric Evans:

“Domain-Drive Design”, arquitectura más conocida como arquitectura DDD.

La arquitectura DDD centra los esfuerzos del desarrollo en el dominio de la aplicación,

en el problema, y a partir de esos dominios se va creando una aplicación con una

arquitectura de N-Capas que según el libro separa en: Persistencia, Infraestructura,

Dominio, Núcleo, Aplicación, Presentación. A esta estructura le añadiremos una capa

más que será API.

c. Tecnologías a utilizar

Empezando de abajo a arriba (back-end a front-end) las tecnologías a usar en las

distintas capas serán:

Persistencia: con SQL Server 2012 Express.

Infraestructura: EF 6, que se utilizará como ORM para el proyecto.

Dominio de la aplicación: C# usando Framework 4.5.

Núcleo (Core): C# usando Framework 4.5.

Aplicación: C# usando Framework 4.5, además se utilizará NLog o Log4Net

para logging.

API: ASP .NET Web API 2 con autenticación ASP .NET Web API Identity y

Middleware OWIN.

Presentación: Existen dos posibilidades, pero sólo se implementará una, a

decisión del alumno según el tiempo disponible:

o ASP NET MVC 5, con Twitter BootStrap 3 más una plantilla de

Wrapbootstrap, y además con la idea de trabajar el patrón MVW

que implementa angularjs en aplicaciones SPA (Simple Page

Application) para los datos de la aplicación. Ninject para Inyección

de Dependencias (DI).

o Silverlight 5. Se crearán las bases para usar el patrón MVVM

añadiendo el framework MVVM light Toolkit

(http://mvvmlight.codeplex.com/ ) pero no se implementará la

presentación completamente, dejándolo a la elección del alumno.

d. Análisis e identificación de riesgos potenciales en el proyecto

Los pocos conocimientos del alumno en MVC5 puede suponer un tiempo extra de

desarrollo que se deberán tener en cuenta en el tiempo asignado para la capa de

presentación. En el seguimiento de esta tarea se puede establecer un tiempo

límite para que el alumno implemente la opción de Silverlight de la que tiene más

conocimiento y tardaría menos en la implementación.

http://mvvmlight.codeplex.com/


13

El desarrollo de un dominio de aplicación que necesite de una infraestructura

basada en un ORM como EF, puede llevar una complicación extra en el

conocimiento de la sintaxis para la creación de la persistencia a través de la

sintaxis utilizada por Code First, por lo que el alumno deberá crear previamente un

diagrama de base de datos que le permita por ingeniería inversa recuperar una

sintaxis de clases, o por otro lado utilizar la creación de la estructura de entidades

mediante la tecnología de EF llamada Database First.


14

4. Diseño En esta parte del proyecto se trabaja en el diseño de todos los componentes de la aplicación

usando distintos diagramas, modelos, prototipos, etc. que se crean para una más fácil

comprensión del trabajo a realizar.

a. Diagrama de casos de uso En el diagrama que viene a continuación se pueden observar 3 actores con distintas

funciones, mientras que Developer y propietario son personas con acceso restringido

al programa, Scrum Master será el actor con el nivel más alto de accesibilidad.

b. Modelo conceptual Modelo que muestra la funcionalidad principal de la aplicación.


15

c. Diagramas de arquitectura

Software

La aplicación se divide en tres capas: Datos, Lógica de negocio y

Presentación, aunque de la capa de la Lógica de negocio se podría extraer

una capa de servicio con Web API se ha preferido unirla a de la Lógica de

negocio.

Hardware

La aplicación se instala en un servidor y se accede a ella mediante cualquier

navegador que soporte HTML5, CSS y JS.


16

d. Diseño de la base de datos La base de datos se ha diseñado sobre un SQL Server 2012 Express, aunque realmente

su creación dependerá de la herramienta EF6 con su versión Code First, es decir, que se

generará una estructura de clases que se reflejará en la Base de datos.

Usuario

id

nombre

apellidos

password

Producto

id

nombre

ProductoUsuario

id

idProducto

idUsuario

rol

Historia

id

idProducto

descripcion

estado

idIteracion

Iteracion

id

descripcion

duracion

orden

idProducto

Tarea

id

descripcion

estado

tipo

horas

idHistoria

idUsuario


17

e. Modelo de clases

f.


18

g. Diseño de la interfaz de usuario (Prototipo) El prototipo se encuentra en el directorio Prototipo y se accede a él abriendo en el

navegador el fichero Default.html. Desde el menú de la izquierda se puede navegar y

acceder a las distintas pantallas de la aplicación que se muestran en el mapa siguiente:

Pantalla de Acceso a la aplicación:

Pantalla principal de la aplicación:


19

Desde la pantalla principal se puede acceder a otras partes de la aplicación como la

pantalla de usuarios

Y la de estadísticas.

Además dentro de cada sección se acceden a pantallas superpuestas que se acceden

desde los botones “Editar” o “Nuevo…”


20

Como la pantalla de “Añadir/Modificar Historias”

“Añadir/Modificar Tareas”

“Añadir/Modificar Iteraciones”


21

“Añadir/Modificar Proyectos”

“Añadir/Modificar Usuarios”

Y por último el acceso a las diferentes partes compuestas de un proyecto se accede

pinchando en el mismo registro de la lista mostrada en esta jerarquía:

Proyecto>Historia>Tareas.


22

Pantalla de historias

Pantalla de tareas

Pantalla de usuarios

Pantalla de iteraciones


23

5. Implementación

a. Decisiones de desarrollo. El desarrollo de la aplicación empezó tal y como estaba previsto con las

herramientas propuestas, pero el lanzamiento del nuevo Visual Studio 2013 el

13 de Noviembre, provocó un cambio de decisión en el desarrollo de la

aplicación. Herramientas nuevas como Web API 2, MVC 5, o el nuevo modelo

de seguridad WEB API Identity se ha incorporado a la aplicación mediante una

adaptación del proyecto.

El nuevo modelo de seguridad WEB API Identity incorpora la creación de una

base de datos con Entity Framework mediante Code First que además

contiene la gestión automática de usuarios. Por ello se ha escogido este

modelo y se ha separado del modelo propuesto en el diseño, creando dos

bases de datos, una del modelo de seguridad de usuarios (ScrumDN.Security) y

otra la propia gestión de usuarios de la aplicación en la base de datos

ScrumDN.

Los tests se han obviado al final debido a que la curva de aprendizaje de las

distintas tecnologías ha sido muy pronunciada, sobre todo tener que

comprobar e incorporar los cambios añadidos en el nuevo Visual Studio 2013.

Para la instalación y configuración del entorno de programación se adjunta un

fichero de Word aparte llamado: “Instalación y configuración del entorno de

desarrollo.docx”.

Para la ejecución de la aplicación se ha creado un manual llamado “Manual de

uso e instrucciones.docx”, además se ha subido a Azure una implementación

de la aplicación y del API para evitar problemas de configuración, ejecución,

etc… en el caso de que se quiera probar, así que la web de dónde se aloja la

aplicación es:

http://scrumDN.azurewebsites.net

El usuario para poder probarla es: demo y la contraseña: 123456.

El api se aloja en: http://ScrumDNAPI.azurewebsites.net y no es ejecutable,

son sólo servicios.

b. Patrones utilizados. Se ha utilizado los siguientes patrones para la implementación:

DDD (Domain Driven Design)

La arquitectura de la aplicación se basa

MVC (Model View Controller)

El patrón se usa para la gestión de datos de la pantalla e interacción con el

usuario.

MVW (Model View Whatever)

En realidad se trata de un patrón MVC, pero los desarrolladores de angularjs y la

comunidad de desarrolladores lo ha rebautizado como MVW.


http://scrumdnapi.azurewebsites.net/


24

c. Dificultades en la implementación. Se han encontrado las siguientes dificultades en la implementación de la aplicación:

El desconocimiento de los frameworks angularj, mvc, webapi y de las

utilidades como ninject, Fiddler y las herramientas de depuración del

navegador Chrome ha sido una gran barrera a sortear en las primeras pruebas

de ejecución, produciendo errores de difícil localización.

El cambio de tecnología mencionado en las decisiones ha retrasado la

implementación del proyecto un par de semanas, que unidas a las dos

primeras semanas de implementación ha creado un retraso excesivo y el

incremento de horas dedicadas al desarrollo en la fase final de este período.

d. Trabajo futuro. Se proponen las siguientes mejoras a la aplicación actual:

Para un desarrollo futuro sería ideal crear un escenario de testeos de al menos

el dominio de la aplicación y la parte de aplicación en si misma.

El seguimiento de los errores con NLog con la grabación de la información de

las excepciones en bases de datos para su posterior visualización.

Inhabilitación de los controles mientras se procede a lecturas de datos, para

evitar carga de la pantalla sin datos y el usuario pueda interaccionar con la

pantalla.

Unificar la base de datos de autenticación con la de usuarios y creación de

roles.

Controles y visualización de errores al usuario producidos por angularjs o

javascript.


25

6. Memoria y presentación Para la memoria y presentación se han creado los siguientes entregables:

Memoria

Se trata de este documento: omontesinos_memoria.docx.

Presentación:

Dentro del fichero omontesinos_presentacion.zip se encuentran los siguientes

entregables:

o Video

Es un video autoejecutable creado con las herramientas Camtasia Studio para

la maquetación e IVONA Reader con la voz “Enrique” para los comentarios.

Ambas versiones son de prueba de 30 días. La grabación del video se ha hecho

desde la aplicación alojada en Windows Azure en el enlace

http://scrumdn.azurewebsites.net.

Este video se puede visualizar de dos maneras distintas:

Desde el directorio omontesinos_presentacion abriendo el fichero

omontesinos_presentacion.mp4.

Desde el mismo directorio pero abriendo con un navegador la página

omontesinos_presentacion.html.

En el video se muestra una demostración del funcionamiento de la aplicación.

o Powerpoint

Se trata de un fichero pptx: omontesinos_presentacion.pptx que presenta la

aplicación mediante diapositivas.



26

7. Conclusión Una vez llegados a este punto, donde se mira hacia atrás y se ve el camino recorrido con los

resultados obtenidos mediante entregables y los resultados no entregables es cuando hay que

hacer una pequeña evaluación de todo el proceso y pensar en lo que se podría obtener en el

futuro.

Lo más importante de este trabajo ha sido el proceso de aprendizaje y la utilización que ello

derivará para afrontar futuros proyectos en la empresa actual dónde trabajo como jefe de

programación. Habría que destacar que lo más importante del proyecto es aprender una

metodología como SCRUM, ágil, fácil, y cuya implantación en la empresa no supondría un gran

trabajo y además tendría su propia recompensa.

Por otro lado una metodología como SCRUM implica un aprendizaje, práctica y un seguimiento

en el que creo que no se puede plasmar en esta aplicación. El camino se ha empezado pero no

se ha terminado, habría que ampliar las funcionalidades propuestas con los siguientes puntos:

Visualización de tareas pendientes por usuarios.

Panel de tareas con estados: Pendiente, Haciéndose, Hecho, Anulado.

Establecer fechas en las iteraciones para una mejor planificación.

Priorización de las historias de usuario.

Gráfica de errores con la evolución temporal del nº de errores.

Añadir un rol nuevo: tester.

Visualización en forma de árbol de historias de usuario con tareas.

Añadir un campo de impedimentos y responsable a las historias de usuarios para

poder darle prioridad en la ejecución si fuera necesario.

En cuanto a las demás tecnologías es importante resaltar la complejidad que conlleva

implementar una arquitectura DDD. La creación del dominio de la aplicación requiere un

conocimiento perfecto del problema a resolver, en este caso la implementación de la gestión

de proyectos con metodología SCRUM, por lo tanto y en este caso, no hubiera sido aconsejable

crear el dominio de la aplicación al mismo tiempo que se estudiaba la metodología SCRUM,

sería recomendable adquirir antes experiencia usando esta metodología en uno o varios

proyectos anteriores.

Aun así y en conclusión, remarcar que la experiencia adquirida en la gestión del tiempo, la

toma decisiones tecnológicas y la división de problemas en problemas más pequeños, permite

adquirir conocimientos nuevos que preparan al estudiante para afrontar cualquier nuevo

proyecto que use las tecnologías aquí presentadas y le da una oportunidad única para afrontar

con garantías su futuro profesional


27

8. Bibliografía y enlaces Scrum

La guía de Scrum traducida al castellano

https://www.scrum.org/Portals/0/Documents/Scrum%20Guides/2013/Scrum-Guide-

ES.pdf#zoom=100

Cómo gestionar proyectos con Scrum

http://www.proyectosagiles.org/

DDD

Artículo de César de la Torre con el enlace para la descarga gratuita de su libro DDD

con Net 4.

http://blogs.msdn.com/b/cesardelatorre/archive/2010/03/11/our-new-net-4-0-ddd-n-

layer-architecture-app-example.aspx

Acceso gratuito al parte del libro de Eric Evans Domain-Driven Design

http://dddcommunity.org/book/evans_2003/

Blogs interesantes de ASP .NET MVC y ASP .NET Web API

Marc Rubiño

http://mrubino.net/

Eduard Tomàs

http://geeks.ms/blogs/etomas/

José M. Aguilar

http://www.variablenotfound.com/

Twitter Bootstrap

http://getbootstrap.com/

Wrapbootstrap

https://wrapbootstrap.com/

Angularjs

http://angularjs.org/

Visual Studio Online

http://www.visualstudio.com

ASP NET

http://www.asp.net/

Camtasia Studio

http://www.techsmith.com/camtasia.html

NaturalReader

http://www.naturalreaders.com/index.php

https://www.scrum.org/Portals/0/Documents/Scrum%20Guides/2013/Scrum-Guide-ES.pdf#zoom=100

https://www.scrum.org/Portals/0/Documents/Scrum%20Guides/2013/Scrum-Guide-ES.pdf#zoom=100

http://www.proyectosagiles.org/

http://blogs.msdn.com/b/cesardelatorre/archive/2010/03/11/our-new-net-4-0-ddd-n-layer-architecture-app-example.aspx

http://blogs.msdn.com/b/cesardelatorre/archive/2010/03/11/our-new-net-4-0-ddd-n-layer-architecture-app-example.aspx

http://dddcommunity.org/book/evans_2003/

http://mrubino.net/

http://geeks.ms/blogs/etomas/

http://www.variablenotfound.com/

http://getbootstrap.com/

https://wrapbootstrap.com/

http://angularjs.org/

http://www.visualstudio.com/

http://www.asp.net/

http://www.techsmith.com/camtasia.html

http://www.naturalreaders.com/index.php

Metodología SCRUM (ScrumDN) -...

Documents

Transcript of Metodología SCRUM (ScrumDN) -...