Está en la página 1de 9

Modelo de Ciclo

de Vida del
Software
Ingeniería de Software II
2014
Integrantes:
Rojas Mescco Pompeyo
Silva Ochoa Jhancarlo
Palomino Taype Iván
- Modelo de Ciclo de Vida del Software
2
Universidad Nacional José María Arguedas


Modelo de Ciclo de Vida del Software

Tabla de contenido

DESARROLLO BASADO EN COMPONENTES ..................................................................................... 2
Definición de Componente ........................................................................................................... 3
Definición de Desarrollo Basado en Componentes ................................................................... 3
Características ................................................................................................................................. 3
Explicación ........................................................................................................................................ 4
Etapas del modelo basado en componentes ............................................................................ 4
Ejemplo de desarrollo basado en componentes ....................................................................... 5
MODELO DE MÉTODOS FORMALES ................................................................................................... 6
Definición .......................................................................................................................................... 6
Explicación ........................................................................................................................................ 6
Ventajas e Inconvenientes ............................................................................................................. 6
Métodos Formales utilizados en el desarrollo de software ........................................................ 7
Ejemplo de Modelo de Métodos Formales .................................................................................. 7
Ejemplo Ilustrativo de Modelo de Métodos Formales ................................................................ 7
DESARROLLO ORIENTADA A ASPECTOS .......................................................................................... 8
Definición .......................................................................................................................................... 8
Desarrollo de software orientado a aspectos ............................................................................. 9




DESARROLLO BASADO EN COMPONENTES

- Modelo de Ciclo de Vida del Software
3
Universidad Nacional José María Arguedas
Definición de Componente
Es una unidad reutilizable que puede trabajar con otros módulos software por medio de sus
interfaces, las cuales definen desde donde se puede tener acceso a los servicios que este ofrece a
los demás componentes.

Un componente puede presentarse en forma de código fuente o código objeto; puede estar escrito
en lenguaje funcional, procedural u orientado a objetos y puede ser tan simple como un botón GUI
o tan complejo como un subsistema.

Definición de Desarrollo Basado en Componentes
El desarrollo de software basado en componentes (DSBC) es el desarrollo de software que describe,
construye y emplea técnicas software para elaborar sistemas abiertos y distribuidos, mediante el
ensamblaje de partes software reutilizables llamados componentes. Es el paradigma de ensamblar
componentes y escribir código para hacer que estos componentes funcionen. El modelo de
desarrollo basado en componentes incorpora muchas de las características del modelo espiral. Es
evolutivo por naturaleza y exige un enfoque interactivo para la creación del software.

Características
El desarrollo de software basado en componentes es utilizado para reducir los costos, tiempo y
esfuerzos de desarrollo del software, y de esta manera incrementar el nivel de productividad de los
grupos desarrolladores y minimizar los riesgos; a su vez ayuda a optimizar la fiabilidad, flexibilidad y
la reutilización de la aplicación final.
La modularidad, la reusabilidad y componibilidad son características muy relevantes de la
tecnología de programación basada en componentes, en las cuales coincide con la tecnología
orientada a objetos de la que puede considerarse una evolución. No obstante en esta tecnología
también se requiere robustez debido a que los componentes deben operar en entornos muchos
más heterogéneos.

- Modelo de Ciclo de Vida del Software
4
Universidad Nacional José María Arguedas
Otro aspecto a tener en cuenta en el DSBC, es el poder integrar lo mejor de las tecnologías para
realizar aplicaciones personalizadas, ajustadas a los requisitos de los clientes; lo cual le permite a
los desarrolladores y empresas adquirir las tecnologías que más se adapten a sus particularidades.

Explicación
El desarrollo de aplicaciones por componentes se basa en la reutilización de código elaborado con
anterioridad, este código en su momento fue probado, y su funcionalidad fue comprobada.

Mediante el uso de varios componentes simples se pueden construir proyectos bastante complejos
los cuales si se realizaran desde el principio tomarían demasiado tiempo, de este modo lo que se
tiene que hacer es revisar nuestros proyectos anteriores o comprar lo que necesitemos de otras
personas, luego de esto podemos pasar a juntar las piezas que se van a reutilizar y las demás piezas
que debemos obligatoriamente especificar y construir para cada proyecto, ya que no todos los
proyectos van a tener la misma oportunidad de reutilización.

Etapas del modelo basado en componentes
1.- Análisis y comparación de procesos de DSBC: Se realiza el estudio de procesos de desarrollo
basado en componentes, en especial de los que utilizan técnicas de modelado. Con extensiones
específicas para componentes, a los fines de definir adaptaciones y extensiones apropiadas de los
mismos.
2.- Análisis arquitectural: Durante esta etapa se realiza el estudio y comparación de diferentes
estilos y patrones arquitecturales, analizando ventajas y desventajas de su utilización para el
desarrollo de este tipo de sistemas, así como de arquitecturas existentes y estándares más
utilizados en la actualidad.
3.- Identificación de componentes: Esta etapa comprende la identificación de interfaces del
sistema, de interfaces del Negocio, la identificación de componentes y la descripción inicial de las
especificaciones de componentes, así como la especificación de la arquitectura inicial de
componentes.
4.- Especificación de los principales componentes: Se trabajará en la especificación de interfaces y
de componentes, definiendo Contratos de uso y Contratos de realización. Se realizan en esta etapa,
los Modelos de Información de Interfaces.
- Modelo de Ciclo de Vida del Software
5
Universidad Nacional José María Arguedas
Representación del ciclo de vida del modelo basado en componentes


Representación del ciclo de vida del modelo basado en componentes


Ejemplo de desarrollo basado en componentes
Un ejemplo es la Web, en donde es posible incluir en páginas HTML multitud de objetos distintos,
como por ejemplo los Applets de Java. Aunque más reciente que OLE (Vinculación e Incrustación de
Objetos), supone un paso atrás en cuanto al concepto que estamos tratando, pues los objetos que
forman parte de las páginas Web no pueden ser a su vez contenedores, es decir, estamos frente a
una tecnología similar a la que ofrecía Visual Basic con sus formularios y controles (aunque ya es
posible en la última versión de Visual Basic definir controles que sean componentes ActiveX, que sı
son contenedores de otros componentes).
En OLE se define el concepto de contenedor y se extiende el concepto de control, que pasa a
denominar cualquier tipo de servidor de documentos. De esta forma los componentes pueden ser
tanto contenedores como servidores de documentos simultáneamente, y es posible que, por
ejemplo, un documento Word se incluya en una hoja de cálculo Excel, que a su vez forme parte de
otro documento Word.
- Modelo de Ciclo de Vida del Software
6
Universidad Nacional José María Arguedas
MODELO DE MÉTODOS FORMALES

Definición
Método formal es cualquier técnica que trate la construcción y/o el análisis de modelos
matemáticos que contribuyen a la automatización del desarrollo de sistemas informáticos.
Los métodos formales permiten representar la especificación del software, verificación y diseño de
componentes mediante notaciones matemáticas.
El uso de métodos formales permite plantear de manera clara la especificación de un sistema,
generando modelos que definen el comportamiento en términos del “qué debe hacer” y no del
“cómo lo hace”.
Explicación
Los métodos formales permiten que un ingeniero del software especifique, desarrolle y verifique un
sistema basado en computadora aplicando una notación rigurosa y matemática, haciendo que lo
incompleto e inconsistencia se descubran y se corrijan más fácilmente, no mediante una revisión a
propósito para el caso, sino mediante la aplicación del análisis matemático.
Aunque todavía no hay un enfoque establecido, los modelos de métodos formales ofrecen la
promesa de un software libre de defectos.

Modelo de Métodos Formales


Ventajas e Inconvenientes
Si bien los métodos formales constituyen un acercamiento alternativo a las metodologías de
desarrollo de software, existen un numero de diferencias significativas que deben de ser
consideradas.
Ofrece un fundamento para entornos de especificación que dan lugar a modelos de análisis más
completos, consistentes y carentes de ambigüedad, que aquellos que se producen empleando
métodos convencionales u orientados a objetos.
- Modelo de Ciclo de Vida del Software
7
Universidad Nacional José María Arguedas
Métodos Formales utilizados en el desarrollo de software
 Métodos formales basados en Lógica de Primer Orden:
Z, B, VDM, Object-Z, Z++ y VDM++.
 Métodos formales basados en Formalismos Algebraicos:
HOSA (Hidden Order Sorted Algebras), TROLL, OBLOG,
Maude y AS-IS (Algebraic S
 Métodos formales basados en Lógica Temporal: TRIO,
OO-LTL y ATOM.
 Métodos Semiformales: Syntropy, Statemate, UML y
OCL (Object Constraint Language)
 Métodos formales basados en Redes de Petri: CO-OPN
(Concurrent Object-Oriented Petri Nets)

Ejemplo de Modelo de Métodos Formales
Meteor, Matra Transport, France: No se encontró ningún error durante el testing de 80000
líneas de código.
SPOT 4, CS-CI, France: Redujo 38 % menos de código fuente 36 % menos de esfuerzo total.
Procesador CISC AAMP5, SRI International, EEUU: Fue posible probar la correctitud
(respecto de la especificación) de una arquitectura dividida en cuatro unidades
independientes, consistente en 500000 transistores, y un conjunto de 108 instrucciones.

Ejemplo Ilustrativo de Modelo de Métodos Formal es
Especificación en lógica formal de las funciones de insertar y borrar elementos en una
estructura pila.



Nótese como, en lugar de utilizar el lenguaje natural para especificar las funciones, se
recurre a la notación Z de la lógica formal para hacerlo. Haciéndolo de esta forma no se
tienen ambigüedades y es posible automatizarlas.

- Modelo de Ciclo de Vida del Software
8
Universidad Nacional José María Arguedas
DESARROLLO ORIENTADA A ASPECTOS

Definición
Un Aspecto es una unidad modular del programa que aparece en otras unidades funcionales del
programa, es la funcionalidad que se cruza a lo largo de la aplicación y que se va a implementar de
forma modular y separada del resto del sistema.

(POA) es un paradigma cuya intención es permitir una adecuada modularización de las aplicaciones,
posibilitando mejor separación de incumbencias. Separa componentes de aspectos creando un
mecanismo para abstraerlos y componerlos Para formar todo el sistema.


Estructura de un Programa Orientado a Aspectos

Un componente es aquella propiedad que se puede encapsular claramente en un procedimiento
(un objeto, un método, un API), mientras que un aspecto no se puede encapsular en un
procedimiento con los lenguajes tradicionales.


- Modelo de Ciclo de Vida del Software
9
Universidad Nacional José María Arguedas
Desarrollo de software orientado a aspectos
El desarrollo de software orientado a aspectos (DSOA) se enfoca en crear una mejor
abstracción modular del sistema. Incluye las siguientes fases:
 Captura de requisitos , separación de intereses tanto los funcionales como los no
funcionales; los requisitos funcionales son modelados con casos de uso que
representan la función básica del sistema y los requisitos no funcionales se
representan con casos de uso de infraestructura.

 Análisis y Diseño , diseño los casos de uso se representan en una estructura de
composición que se identifica con el estereotipo <<use case >> y agrupa elementos de
modelo que colaboran para lograr los requisitos del sistema tanto funcionales como
no funcionales.

 Implementación, se genera el código de las clases y aspectos.

 Pruebas, se diseñan las pruebas para los casos de uso de la aplicación.

Solución POA