Documentos de Académico
Documentos de Profesional
Documentos de Cultura
2018
Patrones, Estándares y Metodologías
para la Construcción de Software
Autores
Miguel García Torres
Carlos Augusto Sánchez Martelo
Henry Leonardo Avendaño Delgado
Manuel Antonio Sierra Rodríguez
Carlos Andrés Collazos Morales
Domingo Alirio Montaño Arias
Breed Yeet Alfonso Corredor
José Daniel Rodríguez Munca
Edición Miembro comité editorial revista Journal of
Editorial Universidad Manuela Beltrán Science Educations. Miembro fundador de la
Sociedad Iberoamericana de Biología Evolutiva.
Autores
Gerente
Juan Carlos Beltrán Gómez
Secretario General
Juan Carlos Tafur Herrera
Autoridades Académicas
Rectora Alejandra Acosta Henríquez
Vicerrectoría de Investigaciones
Carlos Andrés Collazos
ISBN: 978-958-5467-13-2
TABLA DE CONTENIDO
Patrones, Estándares y Metodologías para la Construcción de Software
Contenido
PRÓLOGO ...................................................................................................................................... 13
INTRODUCCIÓN ............................................................................................................................ 15
Capítulo I......................................................................................................................................... 17
1. Interactividad y navegación de aplicaciones ................................................................... 17
1.1. Introducción ....................................................................................................................... 17
1.1.1. Marco Conceptual .................................................................................................................... 18
1.1.2. Ideas Erronas de un Patrón ................................................................................................... 19
1.2. Tipos de Patrones ............................................................................................................ 20
1.2.1. Características de un Patrón ................................................................................................. 21
1.2.2. Patrones de Arquitectura ....................................................................................................... 24
1.2.3. Patrones de Diseño .................................................................................................................. 31
1.2.4. Ejemplos ..................................................................................................................................... 37
1.2.5. Ejercicios de reflexión ............................................................................................................. 41
Capítulo II ....................................................................................................................................... 43
2. Biblioteca de Tecnologías de Infraestructura de Comunicación ITIL ........................ 45
2.1. Introducción ....................................................................................................................... 45
2.2. Historia ................................................................................................................................ 46
2.3. Conceptos básicos de ITIL ............................................................................................ 47
2.4. Ciclo de vida de los servicios ....................................................................................... 51
2.5. Procesos de las fases del ciclo de vida ..................................................................... 53
2.5.1. Estrategia del servicio ............................................................................................................. 53
2.5.2. Diseño del servicio ................................................................................................................... 54
2.5.3. Transición del servicio ............................................................................................................ 55
2.5.4. Operación del servicio ............................................................................................................ 56
2.5.5. Mejora continua del servicio ................................................................................................. 56
2.6. Ejemplos ............................................................................................................................. 58
2.7. Ejercicios de reflexión..................................................................................................... 62
Capítulo III ...................................................................................................................................... 65
3.1. Metodologías para el Desarrollo de Software ........................................................... 66
3.1.1. Introducción ............................................................................................................................... 66
11
3.1.2. Marco Conceptual .................................................................................................................... 66
3.1.3. Metodologías para el Desarrollo de Software ................................................................... 74
3.1.4. Metodologías Ágiles ................................................................................................................ 76
3.1.5. Ejemplos ..................................................................................................................................... 88
3.1.6. Ejercicios de reflexión ............................................................................................................. 93
12
PRÓLOGO
13
14
INTRODUCCIÓN
15
recopila un conjunto de buenas prácticas para la gestión de los servicios; de modo
que estrictamente hablando no es una metodología en sí.
16
CAPÍTULO I
Patrones de Software
1.1. Introducción
El software ha ido aumentando en complejidad a lo largo del tiempo, debido a
diversos factores como la rápida evolución de la tecnología, el aumento del
tamaño de los proyectos de software, el requisito de reutilizar componentes, etc. A
pesar de este aumento de la complejidad, los ingenieros se encuentran con
problemas similares que ya fueron resueltos, y de esa forma no tienen que
“reinventar la rueda” continuamente. Para poder aprovechar soluciones pasadas,
es necesario ser capaz de identificar problemas que sean similares.
17
El estudio de los patrones de diseño nos proporciona un conjunto de
herramientas para poder identificar problemas y asociarles las soluciones
establecidas. Esto nos permite afrontar el desarrollo del software con mayores
garantías de éxito.
Para que una solución sea considerada un patrón debe contar con las
siguientes características:
Las principales motivaciones que podemos encontrar para usar patrones son:
18
Capturan la experiencia acumulada en el desarrollo y mantenimiento de
software y lo pone accesible a profesionales no expertos.
Generan un vocabulario o lenguaje de patrones que permite identificar
mejor las soluciones a problemas comunes.
Permiten una mejora en la comprensión de los problemas que han sido
identificados a lo largo del tiempo.
Pueden ser la base de un manual de ingeniería del software en el que se
documentan y difunden las prácticas exitosas.
Facilitan la reutilización tanto a nivel de diseño como a nivel de código.
Mejoran la posibilidad de evolución del software mediante la identificación
de los aspectos que pueden cambiar.
Existen una serie de ideas erróneas acerca de los patrones que pasamos a
resumir:
19
Los patrones son implementaciones. Tal y como se ha explicado en el punto
anterior, los patrones son abstracciones de problemas y soluciones que se
asocian.
Toda solución es un patrón. Para que una solución sea vista como un patrón,
esta ha de verificarse como una solución recurrente a un problema
recurrente. Para ello, se busca identificar el problema y la solución asociada
en al menos tres ámbitos distintos.
De todos los anteriores, los más populares son los patrones de diseño.
Atendiendo al nivel de abstracción del contexto de aplicación o de la etapa en
proceso de desarrollo podemos distinguir tres categorías:
20
Patrones de diseño. Se refieren a patrones de nivel intermedio que dan
soluciones a problemas detallados de diseño de software.
Patrones elementales. Son específicos de un lenguaje de programación y
describen soluciones útiles para problemas específicos así como el modo
de implementar los distintos componentes particulares de un patrón.
Los patrones suelen estar descritos de manera uniforme. Esto ayuda a que
puedan ser comparados y podamos buscar soluciones alternativas al problema.
21
completa que nos permita sopesarlo para ser aplicado a un problema. Las
distintas características suelen presentarse mediante una plantilla.
Además, los distintos elementos que se usan para describir un patrón dependerá
del tipo de patrón que queramos describir. En Buschmann et al. (1996), los
autores proponen la siguiente plantilla.
22
Plantilla 2. Plantilla propuesta por Alexander para describir un patrón
Nombre Nombre significativo.
Problema Cuestiones del problema que pretende resolver.
Contexto Situaciones que den lugar al problema.
Fuerzas Escenario concreto.
Solución Solución probada al problema.
Ejemplos Una muestra de aplicación del problema.
Contexto resultante El estado del sistema tras aplicar el patrón.
Razón fundamental Explicación de los pasos o reglas del patrón.
Patrones relacionados Relaciones estáticas y dinámicas con otros patrones.
Uso conocido Ocurrencias del patrón dentro del sistema existente.
Fuente: Alexander, C. (1979). The Timeless Way of Building. Oxford: Oxford University Press.
23
Patrones relacionados Otros patrones estrechamente relacionados.
Fuente: Gamma, E., R. Helm, R., Johnson, R., Vlissides, J. (1994). Design Patterns. Elements of
Reusable Object-Oriented Software. Massachusetts: Addison-Wesley.
24
Sistemas distribuidos Broker, CAGS, Client-Server.
Sistemas interactivos MVC, PAC.
Patrones adaptables Microkernel, Reflection.
Fuente: adaptado de Buschmann, F. et al. (1996). Pattern-oriented software
architecture. A system of patterns. Nueva York: John Wiley & Sons.
Los patrones simples están enfocados en apoyar que todas las tareas
necesarias se descompongan y organicen en torno a subtareas que se coordinan
y cooperan. La segunda categoría (sistemas distribuidos) se centra en
infraestructuras para aplicaciones distribuidas. Los patrones Microkernel y Pipes-
Filter pueden entrar en esta categoría, aunque de forma secundaria. La siguiente
categoría (sistemas interactivos) está enfocada a sistemas que requieren de la
interacción humano-computador. Por último, los patrones adaptables hacen
referencia a aquellos sistemas en los que es importante extenderlos, adaptarlos a
la nueva tecnología y/o llevar a cabo cambios de los requerimientos funcionales. A
continuación, pasamos a describir algunos de estos patrones.
1.2.2.1. Layers
La arquitectura por capas es uno de los patrones más usados. Se define como
una organización jerárquica en capas del sistema, en la que cada una provee un
conjunto de servicios a las capas superiores y requiere de los servicios de las
inferiores. La figura 1 muestra un esquema general de este patrón.
25
Figura 1: esquema general del patrón Layer.
Fuente: elaboración propia
26
Fuente: elaboración propia.
27
1.2.2.2. Pipes-Filters
Proporciona una estructura para sistemas que procesan un flujo de datos de
entrada. Cada paso de procesamiento se encapsula en un filtro. Los datos se
pasan a través de tuberías entre filtros adyacentes. Recombinando los filtros
pueden construirse distintas familias de sistemas relacionados. La figura 3
muestra un esquema general de este patrón.
28
Las características básicas de este patrón se muestran en la siguiente tabla.
29
◦ - Los archivos intermedios no son necesarios.
◦ - Flexibilidad.
◦ - Reutilización de filtros.
◦ - Mejora de la eficiencia con procesamiento en paralelo.
Desventajas:
◦ - La compartición de información de estado es caro y poco
flexible.
◦ - Ineficiencia por conversión de datos.
◦ - Errores podrían implicar reiniciar el sistema.
Fuente: adaptado de Ochoa, S. (2005). Introducción a los Patrones (Diseño y Arquitectura). U-
Cursos, CC51A-1 Ingeniería de Software.
1.2.2.3. Model-View-Controller
Como puede verse en la figura 4, este patrón divide una aplicación interactiva
en tres partes. El modelo contiene los datos y la funcionalidad esencial. La vista
despliega la información al usuario y el controlador maneja las entradas. La vista y
el controlador componen la interfaz con el usuario.
30
La descripción de este patrón se muestra en la siguiente tabla:
31
y el ámbito de actuación. Atendiendo al propósito, podemos encontrar tres tipos de
patrones: de creación, de estructura y de comportamiento:
32
Tabla 5. Clasificación de los patrones de diseño popularmente conocidos como Gang
of Four
Patrones de diseño
Propósito
De creación Estructurales De comportamiento
-Interpreter
Clase -Factory method -Adapter
-Template method
-Chain of responsability
-Adapter -Command
-Bridge -Iterator
Ámbito Abstract factory
-Composite -Mediator
Builder
Objeto -Decorator -Memento
Prototype
-Facade -Observer
Singleton
-Flyweight -State
-Proxy -Strategy
-Visitor
Fuente: adaptado de Gamma, E., R. Helm, R., Johnson, R., Vlissides, J. (1994).
Design Patterns. Elements of Reusable Object-Oriented Software. Massachusetts:
Addison-Wesley.
1.2.3.1. Factory
Define una interfaz para crear un objeto pero deja en manos de las subclases el
decidir qué clase instanciar. Deja la instanciación a las subclases en función de los
datos provistos.
Este patrón ayuda a evitar que se viole uno de los principios del diseño
orientado a objetos: “programar para una interfaz, no para una implementación”. Si
el código depende de clases concretas y la API no es estable y puede estar sujeto
a cambios, las dependencias pueden dificultar futuras implementaciones.
Podemos decir que es adecuado usar este patrón si:
33
1.2.3.2. Abstract factory
Provee una interfaz para crear y devolver una familia de objetos relacionados o
dependientes. Es similar al patrón factory pero las diferencias son:
Este patrón permite que una aplicación portable encapsule todas las
dependencias asociadas a la plataforma. Algunas de estas dependencias serían la
base de datos, el sistema operativo, etc.
1.2.3.3. Builder
Separar la construcción de un objeto complejo de su representación, de modo
que el mismo proceso pueda crear distintas representaciones.
1.2.3.4. Singleton
Patrón que se aplica para asegurar que una clase solo tiene una instancia, y
que puede accederse a ella de forma global. Este patrón es útil e importante en
casos de coordinación de acciones a lo largo del sistema (un archivo de sistema,
un administrador de ventanas, etc.). Si hubiera más de una instancia la
complejidad de la acción, así como la probabilidad de error, aumentaría
considerablemente. Usar este patrón si:
Debe haber solo una instancia de una clase y debe ser accesible a los
clientes desde un punto de acceso conocido.
Cuando la instancia podría extenderse mediante herencia y los clientes
podrían usar esta instancia que extiende la original sin modificar su código.
Se suele definir el método Instance () como aquél que permite que los clientes
accedan a la única instancia.
1.2.3.5. Decorator
Este patrón, también conocido como wrapper, aborda el modo de añadir
funcionalidades a un objeto de forma dinámica, a diferencia de la herencia que
sería estática. Por ejemplo, un objeto decorator que contiene un componente de
interfaz de usuario podría añadir una funcionalidad como sería añadir sombra a un
componente, zoom, etc. Este patrón se usa en los siguientes casos:
1.2.3.6. Facade
Este patrón proporciona una interfaz unificada para un conjunto de interfaces
del sistema. Define una interfaz de alto nivel que hace que el subsistema sea más
sencillo de usar. Este patrón se usa si:
1.2.3.7. Iterator
Define una interfaz que declara los métodos necesarios para acceder
secuencialmente a un grupo de objetos de una colección, independientemente de
su estructura. Las circunstancias en las que se usan son:
1.2.3.8. Observer
Define una dependencia del tipo uno-a-muchos entre objetos, de manera que
cuando uno de los objetos cambia su estado, notifica este cambio a todos los
dependientes. Se usa en los siguientes casos:
1.2.4. Ejemplos
Ejemplo 1: Patrones arquitectónicos
El problema KWIC (KeyWord In Context) consiste en que dado una lista de líneas
como entrada, hay que permutar, pasando la última palabra al principio de la línea
(Circular Shift). Por ejemplo, si tenemos la siguiente línea:
man eats dog
37
llamada. La comunicación de los datos se hace mediante este último método.
Como puede verse, la organización en capas está basada en objetos que llaman
métodos de la misma capa o de la capa contigua.
La ventaja de esta solución es que los datos están escondidos dentro de los
objetos. Esto implica que las elecciones de las estructuras de datos y los
algoritmos estén encapsulados en componentes específicos. Lo que facilita futuros
cambios que mantengan las interfaces abstractas presentes.
38
También podemos resolver este problema haciendo uso del patrón pipe-filter. La
figura 6 muestra cómo quedaría la solución. En este caso, se construiría una
cadena de transformaciones y se necesitaría que los datos estuvieran en un
formato uniforme. También se pueden esconder los datos, pero teniendo en
cuenta la uniformidad de estos. En caso de que tuviéramos que manejar
internamente distintas estructuras de datos dentro de cada filtro, habría una
pérdida de eficiencia debido a la transformación de los datos al formato común.
Fuente: http://www.es.w3eacademy.com/design_pattern/factory_pattern.htm
39
Si en este proyecto ampliásemos el diseño a los colores también, sería
conveniente usar el patrón AbstractFactory, el cual puede ser visto como una
fábrica de fábricas.
Fuente: http://www.es.w3eacademy.com/design_pattern/abstract_factory_pattern.htm
40
AbstractFactoryPatternDemo es la clase principal que hace uso del generador de
fábricas. Primero genera el tipo de fábrica que le interesa y posteriormente le pasa
el tipo de información de entrada asociada a dicha fábrica.
2. Describa cada uno de los patrones de diseño vistos, ajustándose a la plantilla mostrada a
continuación.
Nombre y clasificación
Propósito
Conocido como
Motivación
Aplicabilidad
Estructura
Participantes
Colaboración
Consecuencias
Usos conocidos
Patrones relacionados
41
42
CAPÍTULO II
Estándares de TI
43
44
2. BIBLIOTECA DE TECNOLOGÍAS DE INFRAESTRUCTURA DE COMUNICACIÓN
ITIL
2.1. Introducción
En la actualidad, cualquier organización tiene una dependencia tecnológica que
va en aumento a medida que aumenta el tamaño de dicha organización. En este
contexto, ITIL (Information Technology Infrastructure Library) proporciona un
marco de referencia para alinear la tecnología con las líneas estratégicas de
negocio de la organización.
45
Mejor productividad. El uso de ITIL repercute en una disminución de los
incidentes así como en una resolución más eficiente de estos y evita tener
que aclarar aspectos relacionados con la gestión de dichos incidentes.
Mayor confianza. El establecimiento de ITIL como un estándar a nivel global
aporta una mayor garantía de su utilidad en los procesos de mejora así
como en la escalabilidad para el futuro.
Finalmente, cabe destacar que hay una certificación ITIL que acredita a
individuos (no a empresas) por la adquisición de un nivel de conocimientos
determinado en lo relativo a la gestión de servicios TI. La adquisición de estos
conocimientos por parte de los trabajadores dentro de una empresa u
organización permite la creación de estrategias básicas para la gestión de
servicios TI.
2.2. Historia
ITIL (Information Technology Infrastructure Library) es un conjunto de
publicaciones de las mejoras prácticas para la gestión de servicios TI.
46
A principio de los 90 las grandes compañías europeas fueron adoptando dichas
prácticas tanto en el ámbito gubernamental como privado. En el año 2000 la CCTA
pasó a ser OGC y Microsoft adoptó ITIL como base para desarrollar MOP
(Microsoft Operations Framework). La versión 2 de ITIL apareció en 2001 y aportó
una mejor precisión en lo relativo a los servicios de mantenimiento y suministro.
En los siguientes años se extendió su uso como buena práctica a lo largo del
planeta. En 2007 salió la versión 3 de ITIL, la cual orienta la gestión de servicios
desde una aproximación de ciclos de vida, con un mayor énfasis en la integración
de negocios TI.
Son cuantificables
47
◦ Conjunto de actividades con el objetivo de cumplir un cometido
específico.
48
objetivo que se persigue con las funciones es la de dotar a las organizaciones de
una estructura acorde al principio de especialización.
Otro concepto de importancia en ITIL es la de rol, el cual no es más que un
conjunto de actividades y responsabilidades asignadas a una persona o grupo. Sin
embargo, una persona o grupo puede desempeñar más de un rol.
Hay cuatro roles genéricos que son especialmente importantes para la gestión de
servicios TI:
49
Los acrónimos de RACI hacen referencia a lo siguiente:
En una tarea solo puede haber un único R y A. En caso contrario, dicha tarea se
subdividirá en múltiples tareas hasta que así sea. Una matriz RACI típica tiene un
eje vertical donde se describen las tareas o entregables en orden cronológico y un
eje horizontal con los perfiles de las personas implicadas en los mismos. A
continuación, ponemos un ejemplo del reparto de roles en la realización de una
copia de seguridad de una base de datos perteneciente a una aplicación de un
sistema de información (ver tabla 1).
50
2.4. Ciclo de vida de los servicios
La versión 3 de ITIL orienta el servicio TI a las 5 fases del ciclo de vida:
Hay que tener en cuenta que estas fases no son independientes entre sí sino
que están interrelacionadas de una manera cíclica y esto afecta al propio ciclo de
vida del servicio.
La figura 1 muestra de forma esquemática las 5 fases del ciclo de vida. Como
puede verse, la fase de estrategia del servicio basado en ITIL es central al
concepto de ciclo de vida del servicio. Tiene como principal objetivo convertir la
gestión del servicio en un activo estratégico para la organización. Para ello debe
identificar a la competencia y competir con ella diferenciándose y ofreciendo un
mejor rendimiento. El valor ofrecido al cliente no solo se aprecia en los resultados
del negocio sino también en la percepción que se tiene de este. En ITIL el valor de
un servicio se asocia a los conceptos de utilidad (o funcionalidad) y garantía. La
funcionalidad es el producto que recibe un cliente. Está relacionado con los
atributos del servicio que repercuten positivamente sobre el rendimiento de
actividades, objetos y tareas. La garantía, en cambio, reside en cómo se
51
proporciona el producto. Se relaciona más con la disponibilidad, fiabilidad,
continuidad y seguridad del servicio.
Fuente: http://www.milldesk.cl/2013/10/que-es-itil/#.WdCkt58ypD8
La siguiente etapa, transición del servicio, tiene la misión de servir como guía
para asegurar que los servicios nuevos, modificados o retirados satisfagan las
expectativas del negocio, tal y como se documenta en las dos etapas anteriores
dentro del ciclo de vida.
52
A continuación, viene la fase operaciones del servicio, que tiene el fin de que
los servicios sean correctamente prestados y aporten el valor y la utilidad
requeridos, con los niveles de calidad acordados y verificados por todas las partes.
Por último, la fase mejora continua del servicio asegura que los servicios
estén alineados con necesidades cambiantes del negocio. Esto se lleva a cabo por
medio de la identificación e implementación de mejoras en los servicios de TI que
dan soporte a los procesos de negocio. Para ello, se mide constantemente el
desempeño del proveedor de servicios TI con el fin de mejorar la eficiencia, la
efectividad y la rentabilidad del servicio prestado.
53
2.5.2. Diseño del servicio
◦ Coordinación del diseño. Es responsable de coordinar todas las
actividades de diseño de servicios, procesos y recursos.
54
2.5.3. Transición del servicio
Planificación de la transición y soporte. Es el proceso encargado de proveer
planeación para la transición del servicio y coordinar los recursos que sean
requeridos.
Gestión del conocimiento. Proceso que asegura que la información correcta sea
entregada en el lugar apropiado o a la persona adecuada en el tiempo correcto
para la toma de decisiones informadas.
55
2.5.4. Operación del servicio
Gestión de eventos. Proceso encargado de gestionar eventos a través del ciclo
de vida del servicio. Realiza actividades como detectar eventos, darles sentido y
determinar las acciones de control adecuadas.
56
Service Desk. Es el único punto de contacto entre el proveedor de servicios y el
usuario. Realiza tareas del tipo manejar incidentes, solicitudes de servicio y de
comunicación con los usuarios.
Figura 2: procesos y funciones de las distintas fases del ciclo de vida de los servicios TI.
Fuente: Pultorack, s. f. recuperado de: https://cdn.shopify.com/s/files/1/1062/8666/files/ITIL-2011-
Lifecycle-Processes-Functions-Wallpaper-1280x800.jpg?9564622448967946673
57
2.6. Ejemplos
Un servicio de gestión de incidencias es un proceso para acceder, grabar y
resolver incidencias. El propósito de este proceso es poder restaurar el servicio al
cliente lo más rápido posible.
Este proceso incluye todo evento que interrumpa o que podría interrumpir un
servicio. Para gestionar los incidentes es necesario saber las actividades
asociadas a este proceso, las cuales son:
Identificar el incidente.
Registrar el incidente.
Clasificar el incidente.
Priorizar el incidente.
Diagnóstico inicial.
58
Escalar el incidente.
Investigar y diagnosticar.
Resolver y recuperar.
Cerrar incidente.
59
Finalmente, cabe destacar los roles y responsabilidades de este proceso:
60
Figura 3: Diagrama de la gestión de incidentes.
61
2.7. Ejercicios de reflexión
62
La administración tiene un mayor control, se estandarizan e
identifican los procedimientos, y los cambios resultan más fáciles de
manejar.
La estructura de procesos en TI proporciona un marco para concretar
de manera más adecuada los servicios de outsourcing.
A través de las mejores prácticas de ITIL se apoya al cambio de la
cultura de TI y su orientación hacia el servicio, y se facilita la
introducción de un sistema de administración de calidad.
ITIL proporciona un marco de referencia uniforme para la
comunicación interna y con proveedores.
Inconvenientes
Tiempo y esfuerzo necesario para su implementación.
Falta de comprensión o conocimiento sobre la adopción de ITIL.
Que no se dé el cambio en la cultura de las áreas involucradas.
Que no se vea reflejada una mejora por falta de entendimiento sobre
procesos, indicadores y cómo pueden ser controlados.
Que el personal no se involucre y se comprometa.
La mejora del servicio y la reducción de costos no sea visible.
Que la inversión en herramientas de soporte sea escasa. Los
procesos podrán parecer inútiles y no se alcanzan las mejoras en los
servicios.
63
64
CAPÍTULO III
65
3.1. Metodologías para el Desarrollo de Software
3.1.1. Introducción
El desarrollo de software es un marco de trabajo para la gestión de proyectos
de software que asegura la consecución de unos hitos, así como la calidad del
producto desarrollado. Tiene como principal objetivo la producción eficaz y
eficiente de un producto de software que reúna los requisitos del cliente.
66
Los sistemas no responden a las expectativas de los usuarios.
Las aplicaciones suelen contener errores.
Los cambios en el hardware suelen afectar al software.
Es muy difícil hacer un aprovechamiento óptimo de los recursos.
67
Figura 4: capas de la ingeniería del software.
Fuente: http://sosagas.blogspot.com.es/2011/09/capas-de-la-ingenieria-de-software.html
68
Diseño e implementación. Abarca el diseño y construcción del
software de acuerdo a la especificación.
Validación. Conlleva el conjunto de actividades asociadas a la
validación del software desarrollado para que cumpla con las
expectativas del cliente.
Evolución. El software ha de ir modificándose para adaptarse a las
necesidades del cliente.
69
Las actividades de protección. Son un conjunto de actividades
independientes de cualquier actividad del marco de trabajo y
aparecen durante todo el proceso. El objetivo es la gestión, el rastreo
y el control del proyecto para garantizar la calidad del software.
70
Quién: las personas participantes en el proyecto de desarrollo
desempeñan uno o más roles específicos.
Qué: los artefactos se especifican utilizando notaciones específicas.
Las herramientas apoyan la elaboración de artefactos y soportan
ciertas notaciones.
Cómo y cuándo: las actividades son una serie de pasos que llevan
a cabo un rol durante el proceso de desarrollo. El avance del
proyecto está controlado mediante hitos que establecen un
determinado estado de terminación de ciertos artefactos.
◦ Escribir código.
71
◦ Código difícil y costoso de mantener.
La interacción entre las distintas fases puede consultarse en la figura 3. Una fase
no comienza hasta que termina la anterior. En la práctica este modelo requiere de
varias iteraciones así como de la interacción entre las distintas fases de desarrollo.
72
Figura 6: modelo de desarrollo en cascada.
Fuente: http://users.dsic.upv.es/asignaturas/facultad/lsi/doc/IntroduccionProcesoSW.doc
◦ Existe una alta probabilidad de que el software no cumpla con los requisitos
del usuario por el largo tiempo de entrega del producto.
Cada vuelta de ciclo se compone de cuatro fases, ocupando cada una de estas
fases un cuadrante:
73
◦ Evaluación y reducción de riesgos. Se analizan en detalle los riesgos, se
evalúan alternativas y se enfoca en la resolución de estos riesgos.
74
No existe una clasificación única de los distintos tipos de metodología sino que
dependerá del criterio que se utilice. Si consideramos como criterio las notaciones
usadas para especificar artefactos producidos en actividades de análisis y diseño,
podemos clasificar las metodologías en dos grupos:
75
3.1.4. Metodologías Ágiles
En el proceso de desarrollo de software se hacía un especial énfasis en el
control del proceso mediante una definición de roles, actividades y artefactos,
incluyendo modelado y documentación. Este esquema, que ha demostrado ser
efectivo en proyectos de gran tamaño, ha dejado de ser efectivo en muchos
proyectos actuales debido a lo cambiante del entorno del sistema. En este
contexto, surgen las metodologías ágiles como posible respuesta a esta
necesidad, pues aportan una simplificación del proceso de desarrollo y mantiene
la calidad del producto.
76
Estos valores dan pie a los doce principios del manifiesto, los cuales marcan la
diferencia con respecto a la metodología tradicional. Algunas de las metodologías
ágiles que podemos encontrar son:
SCRUM
Crystal Methodologies
Dynamic Systems Development Method
Adaptive Software Development
Feature-Driven Development
Lean Development
eXtreme Programming (XP)
3.1.4.1.1. Valores
XP se basa en los siguientes valores:
Comunicación fluida entre los miembros del equipo y con el cliente.
Simplicidad en la búsqueda de soluciones. Siempre se eligen las
soluciones más simples que se adecuen a las exigencias del cliente.
Retroalimentación continua del cliente para que los desarrolladores
puedan dirigir el proyecto adecuadamente.
Valentía para llevar a cabo los cambios que vayan siendo necesarios
aplicar.
Respeto en el trato entre los miembros integrantes del proyecto de
modo que no quieran hacerse decisiones repentinas.
77
3.1.4.1.2. Roles
Los roles de acuerdo con la propuesta original de Beck (1999) son:
Programador. Es el encargado de implementar el código del sistema
y escribir las pruebas unitarias.
Cliente. Es un interlocutor que puede representar a una o varias
personas. Se encarga de describir el sistema así como las
prioridades de los distintos componentes.
Encargado de pruebas (Tester). Es el encargado de ayudar al cliente
a escribir las pruebas funcionales. También ejecuta las pruebas y
difunde los resultados.
Encargado de seguimiento (Tracker). Es el encargado de seguir y
verificar el grado de cumplimiento de los objetivos marcados tanto a
nivel de tiempo como de recursos.
Entrenador (Coach). Es el responsable del proceso global. Sirve de
guía a los miembros del equipo para que apliquen las prácticas XP
adecuadamente.
Consultor. Es un miembro externo del equipo que guía al equipo para
resolver un problema específico.
Gestor (Big boss). Es el vínculo entre el cliente y el equipo. Su
principal trabajo es el de coordinar para que el equipo trabaje en las
mejores condiciones.
3.1.4.1.3. Modelo
La metodología XP define cuatro variables para cualquier proyecto de software:
costo, tiempo, calidad y alcance. Tres de estas variables pueden ser establecidas
por actores externos al equipo de desarrollo, mientras que la cuarta la establecerá
el equipo de desarrollo en función de las otras variables. Por ejemplo, si el cliente
establece el alcance y la calidad, y el jefe del proyecto el costo, el equipo de
desarrollo determinará el tiempo de desarrollo necesario.
78
El desarrollo se organiza en torno a ciclos cortos denominados iteraciones, que
tienen asociados una serie de entregables al finalizar cada una de ellas. En cada
iteración se lleva a cabo un ciclo completo de análisis, diseño, desarrollo y
pruebas adecuadas a las reglas y prácticas que caracterizan a XP.
Figura 8: comparación de las iteraciones en los desarrollo en cascada (a), en el iterativo (b) y en
XP (c).
Fuente: http://www.runayupay.org/publicaciones/2244_555_COD_18_290814203015.pdf
3.1.4.1.4. Proceso
A grandes rasgos el ciclo de desarrollo consiste en los siguientes pasos:
79
El ciclo de vida ideal se compone de seis fases:
80
3.1.4.1.5. Reglas y prácticas
La aplicación con éxito de la metodología XP requiere del cumplimiento de un
conjunto importante de reglas y prácticas. A continuación, pasamos a describir
algunas de estas:
Planificación. Hay dos actores principales: el cliente y el programador. El
primero establece las historias de cada usuario y su prioridad, mientras que el
programador establece el esfuerzo asociado a cada historia. Se ordenan las
historias en función de la prioridad y el esfuerzo, y se define el contenido de cada
iteración. Esto se realiza durante la planificación de la entrega, en la planificación
de cada iteración y en cualquier momento que sea necesario.
Entregas. La idea que subyace es que haya entregas de versiones
operativas aunque no cuenten con todas las funcionalidades pero que tengan un
cierto valor para el negocio.
Simplicidad del diseño. Se debe diseñar la solución más simple que pueda
funcionar y ser implementada.
Pruebas. Las pruebas unitarias son establecidas antes de escribir el código.
Para ello, los clientes establecen las pruebas funcionales para cada historia de
usuario.
Refactorización. El código se reestructura constantemente con el objetivo
de eliminar código duplicado, mejorar su legibilidad, simplificarlo y hacerlo más
flexible para facilitar futuros cambios.
Propiedad colectiva del código. Cualquier programador puede contribuir en
la mejora o modificación del código para evitar que alguno de ellos sea
imprescindible.
Integración continua. En cada momento en que un módulo es terminado se
pasa a su integración en el sistema. Para ello hay que planificar y automatizar el
conjunto de pruebas necesarias para que el código sea integrado en el sistema
una vez supere con éxito dichas pruebas.
81
Estándares de programación. Se motiva el uso de estándares de
programación que permitan mantener un código legible para los miembros del
equipo.
3.1.4.2. Scrum
Scrum nace en 1986 de la mano de Takecuchi y Nonaka en 1986 para gestionar
proyectos en los que la agilidad, flexibilidad y las incertidumbres son elementos
fundamentales en torno al proyecto. Posteriormente, en 1993 Sutherland lo aplica
al modelo de desarrollo de software. Esta metodología está formada por un
conjunto de prácticas y reglas para poder emprender proyectos complejos
adaptativos. Da respuesta a los siguientes principios de desarrollo ágil:
Gestión evolutiva del producto.
Calidad del resultado basado en el conocimiento de cada miembro
del equipo, antes que en el explícito de los procesos y la tecnología
empleada.
Estrategia de desarrollo incremental a través de iteraciones (sprints).
3.1.4.2.1. Valores
La metodología Scrum se sirve de unos valores que ayudan a obtener el éxito. La
figura 6 muestra un diagrama con estos valores, los cuales pasamos a describir a
continuación:
82
Foco. Las distintas tareas de un proyecto pueden ser muy variadas.
Los equipos han de estar unidos con un foco en común para crear
cohesión.
Coraje. Los recursos y los datos son compartidos de modo que
ninguno se sienta aislado. Con el apoyo y el soporte del grupo se
hace posible la innovación.
Apertura. La transparencia y la compartición de datos permite una
mayor eficiencia en la respuesta a las necesidades que van
surgiendo así como a la reestructuración de procesos.
Compromiso. Los miembros del equipo aumentan su compromiso si
pueden encauzar su propio éxito mediante la consecución de los
objetivos de su parte dentro del todo que es el proyecto.
Respeto. Al trabajar en equipo y compartir información, es
fundamental el respeto hacia los demás y los procesos compartidos
para obtener los resultados esperados.
3.1.4.2.2. Roles
En Scrum se diferencian dos tipos de roles fundamentales:
Roles principales. Son aquellas personas o roles comprometidos con el
proyecto y el proceso Scrum.
83
◦ Dueño del producto (Product owner). Es una única persona responsable
de gestionar la lista del producto (Product Backlog). Conoce el negocio
del cliente y tiene visión del producto. Se encarga de escribir las ideas
del cliente, ordenarlas en función de la prioridad y colocarlas en la lista
del producto de forma visible, clara y transparente para todos.
3.1.4.2.3. Proceso
En Scrum se denomina sprint a la unidad básica de trabajo para un equipo, y
consiste en una simple iteración de modo que a su finalización se tiene que
proporcionar un resultado completo, un incremento del producto final. El tiempo
mínimo de un sprint es de una semana y el máximo es de 4.
84
eventos tienen una duración máxima. De esta forma, un sprint puede considerarse
como un contenedor de eventos. A continuación pasamos a describir los eventos:
Objetivos del sprint (Sprint goals). Es la meta considerada para el sprint que
puede lograrse mediante la implementación de la lista de producto. Se crea
durante la planificación del sprint.
85
dueño del producto se reúne con el equipo y el facilitador para hablar de lo
ocurrido en el pasado sprint. El objetivo es revisar lo que se hizo y crear un plan
de mejoras que sean abordadas en el siguiente sprint. Los puntos principales a
tratar son:
La lista es creada y gestionada por el cliente con ayuda del facilitador, quien
indicará el coste estimado para completar un requisito. Las principales
característica de esta lista son:
◦ Ha de incluir los posibles riesgos así como las tareas necesarias para
solventarlos.
86
Lista o pila de pendientes del sprint (Sprint backlog). Es la lista de tareas
correspondientes a un sprint y se elabora por el equipo durante la planificación de
un sprint. Se asignan las tareas a las personas y el tiempo que queda para
terminarlas. Se caracterizar por:
87
A continuación, se lleva a cabo la reunión de planificación de sprint para dividir
las tareas en iteraciones (sprints). De modo que cada iteración contendrá una
serie de tareas asociadas. Esto se plasma en el documento denominado Lista de
pendientes de sprint (Sprint Backlog) y es responsabilidad exclusiva del equipo de
desarrollo.
En este momento empiezan las iteraciones en las que los distintos miembros
del equipo llevan a cabo trabajos de desarrollo y prueba. En esta etapa se llevan a
cabo reuniones diarias (Daily Scrum Meeting).
3.1.5. Ejemplos
Caso práctico de uso de la metodología Scrum
Consideremos que un cliente se pone en contacto con una empresa de
desarrollo de robots. Como se ve en la figura 8, el cliente se reúne con el dueño
del producto, quien toma nota de sus necesidades.
88
Figura 11: reunión entre el cliente y el dueño del producto.
Fuente: https://www.slideshare.net/FlowersInSpace/introduccion-a-scrum-con-caso-prctico-
1516220
89
Figura 13: estimación del coste por parte del facilitador.
Fuente: https://www.slideshare.net/FlowersInSpace/introduccion-a-scrum-con-caso-prctico-
1516220
Una vez aprobado el presupuesto por parte del cliente, se reordena la lista de
producto en función de las prioridades del propio cliente para que el equipo trabaje
según ese orden establecido.
90
Figura 15: iteración de una historia de usuario.
Fuente: https://www.slideshare.net/FlowersInSpace/introduccion-a-scrum-con-
caso-prctico-1516220
91
Fuente: https://www.slideshare.net/FlowersInSpace/introduccion-a-scrum-con-
caso-prctico-1516220
El equipo comienza el Sprint tomando las tareas priorizadas. Una vez concluida
una, se toma la siguiente de la lista.
Todos los días se convoca una reunión del equipo donde se cuenta las tareas
realizadas el día anterior y cuáles se van a realizar ese día. La figura 14 muestra
un esquema de ejemplo de los asuntos a tratar en una de las reuniones diarias.
92
3.1.6. Ejercicios de reflexión
1. Haga una comparación que exponga las diferencias entre las metodologías
ágiles y las tradicionales.
Metodologías ágiles Metodologías tradicionales
Basadas en normas provenientes de
Basadas en heurísticas provenientes de
estándares seguidos por el entorno
prácticas de producción de código.
de desarrollo.
Especialmente preparados para cambios
Cierta resistencia a los cambios.
durante el proyecto.
Impuestas internamente (por el equipo de
Impuestas externamente.
desarrollo).
Proceso menos controlado, con pocos Proceso mucho más controlado, con
principios. numerosas políticas/normas.
No existe contrato tradicional o al menos es
Existe un contrato prefijado.
bastante flexible.
El cliente interactúa con el equipo de
El cliente es parte del equipo de desarrollo.
desarrollo mediante reuniones.
Grupos pequeños (<10 integrantes) que Grupos grandes y posiblemente
trabajan en el mismo sitio. distribuidos.
Pocos artefactos. Más artefactos.
Pocos roles. Más roles.
La arquitectura del software es
Menos énfasis en la arquitectura del
esencial y se expresa mediante
software.
modelos.
93
flexibilidad necesaria, aunque es posible en los ciclos de vida predictivos, resulta
demasiado cara.
94
e. Los proyectos se desarrollan en torno a individuos motivados. Hay
que darles el entorno y el apoyo que necesitan, y confiarles la ejecución del
trabajo.
Un entorno ágil se basa en un equipo multifuncional y autoorganizado que se
autogestiona y encuentra su camino en lugar de recibir órdenes. Esta es una gran
responsabilidad para los desarrolladores, y no todos son capaces de trabajar de
esta manera. Cuando tenemos los miembros de equipo adecuados, debemos
confiar en ellos, motivarles y darles la posibilidad de permitir la agilidad
96
Por lo general, la gente trabaja mejor cuando se siente respetada y están
autorizados para decidir cómo funcionar. Además, es mejor que todos los
miembros del equipo sean responsables de todo el proyecto. Por ejemplo, sí los
diseñadores no funcionan de manera aislada, entonces estarán constantemente
en contacto con los programadores y pueden utilizar la información que se genera
para mejorar los diseños y hacerlos más prácticos.
97
98
CONCLUSIONES
99
ser por cada etapa. Continuando con el ejemplo del patrón Pipe-Filter, cabe
destacar que esto no es posible en este patrón.
100
tendencias o patrones que puedan derivar en una oportunidad de mejora y, a su
vez, redunda en la mejora de la calidad del servicio.
De entre todas las metodologías ágiles, XP y Scrum son dos de las más
extendidas en los entornos de desarrollo. La selección de la metodología
dependerá de las características del proyecto que se maneje y del conocimiento
que manejen los miembros del equipo de desarrollo del proyecto.
101
102
Bibliografía
Appleton, B., (2000) Patterns and software: Essential concepts and terminology.
Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P., y Stal, M. (1996).
Pattern-oriented software architecture. A system of patterns. Nueva York: John
Wiley & Sons.
Gamma, E., R. Helm, R., Johnson, R., Vlissides, J. (1994). Design Patterns.
Elements of Reusable Object-Oriented Software. Massachusetts: Addison-Wesley.
103
Círculo-Tec. En línea con tu desarrollo. (2012d). Transición del servicio (ST).
Recuperado de:
ftp://sata.ruv.itesm.mx/portalesTE/Portales/Proyectos/Seminarios/itil/tisg007_version_imp
resa.pdf
104
105
106
107
978-958-5467-13-2
108