2015

Desarrollo Evolutivo, Incremental y Prototipos

SOFTWARE DE COMUNICACIONES

PROFESOR: ING. ALEXIS MORA G.

ESTUDIANTES:

ADEMIR RASMIJNFELIPE RUIZ QUESADA

CHRISTOPHER MADURO

ContenidoIntroducción.............................................................................................................................................2

Modelo incremental................................................................................................................................3

Historia..................................................................................................................................................3

Concepto..............................................................................................................................................3

¿En qué consiste?..............................................................................................................................4

Etapas....................................................................................................................................................4

Características....................................................................................................................................6

Modelo Prototipos..................................................................................................................................7

Historia..................................................................................................................................................7

Concepto..............................................................................................................................................7

¿Qué es el modelo de prototipos?.................................................................................................8

Desarrollo.............................................................................................................................................8

Etapas..................................................................................................................................................10

Caracteristicas..................................................................................................................................11

Comparación entre métodos.............................................................................................................12

Evolutivo contra incremental.............................................................................................................12

Diferencias entre el incremental y prototipos..................................................................................12

Conclusión.............................................................................................................................................13

Bibliografía................................................................................................................................................14

Introducción

Debido a lo complejo que resulta el desarrollo de software, se deben buscar métodos que permitan definir claramente un ciclo de vida del software. Para garantizar que este cumpla con los objetivos previstos al inicio.

Los métodos de desarrollo de software son un conjunto de herramientas, técnicas y procesos que brindan soporte y facilitan el logro u obtención de una meta.

El ciclo de vida de un producto de software define sus etapas desde su análisis, diseño, desarrollo, implementa

Modelo incremental

Al igual que los otros métodos de modelado, el Modelo Incremental es de naturaleza interactiva pero se diferencia de aquellos en que al final de cada incremento se entrega un producto completamente operacional.

El Modelo Incremental es particularmente útil cuando no se cuenta con una dotación de personal suficiente. Los primeros pasos los pueden realizar un grupo reducido de personas y en cada incremento se puede añadir personal, de ser necesario.

Historia

El modelo fue propuesto por Haralan Mills en 1980. Sugirió como una forma de reducir la repetición del trabajo en el proceso de desarrollo y dar oportunidad de retrasar la toma de decisiones en los requisitos, hasta adquirir experiencia con el sistema. Surge porque en los primeros desarrollos se podía esperar largo tiempo hasta que el software estuviese listo. Las reglas del negocio de hoy no lo permiten.

Concepto

Es un modelo para el desarrollo de software en el que se realizan secuencias lineales de forma escalonada mientras se progresa en el tiempo. Cada secuencia lineal produce un incremento en el software.

Durante el proceso se trata de llevar a cabo el proyecto en diferentes partes, para que al final terminará siendo una solución completa, de esta forma poder resolver las necesidades planteadas por el cliente.

Sin embargo, estos incrementos no se pueden realizar de forma aleatoria. Sino que depende del cliente, de cual necesidad es más urgente de los puntos del proyecto.

Se busca realizar los incrementos más básicos, complejos y de mayor riesgo lo más pronto posible. Para que el proyecto conforme avance en el tiempo disminuya el riesgo y aumenten las posibilidades de éxito.

¿En qué consiste?

Consiste en un método de desarrollo de software donde se realiza un desarrollo inicial de la arquitectura del sistema. Este primer desarrollo esencial es denominado núcleo.

A este núcleo, se le agregaran incrementos, donde cada uno posee su propio ciclo de vida. Se basan en el anterior, pero no cambian ni su funcionabilidad ni sus interfaces.

Al principio se crea un plan de incrementos, basado en las funciones priorizadas según el cliente. Cada incremento representa un subconjunto de funciones del sistema que se entregará.

EtapasGeneralmente el proceso se divide en cuatro etapas: Análisis, diseño, codificación y pruebas.

Análisis

Definir con detalle las necesidades que tendrán que resolver el software, sin tomar encuentra los medios técnicos necesarios. Es decir, se definen los requisitos del sistema.

Con base a esto se redacta la especificación de requisitos, el cual especificara que debe hacer el software abarcando lo más importante para que se pueda desarrollar.

Diseño

Especifica una solución al problema planteado en la etapa de análisis. También nos indica como el software debe realizar sus funciones. Hay que definir su arquitectura en general, las interfaces del usuario.

A partir de todo lo anterior se debe codificar el software. Se puede hacer la comparación con la construcción de un edificio, donde todo lo especificado anteriormente nos servirá como plano para la construcción del sistema.

De esta etapa de obtendrá el documento es la especificación del diseño. También esta etapa es el mejor momento para elaborar la especificación de la prueba (define con que datos se debe probar cada programa, los cuales son los resultados esperados en cada paso)

Codificación

Es la etapa en la se traduce el diseño plantado en las etapas anteriores en código procesable en la computadora. Se empieza la elaboración del sistema propiamente.

En esta etapa se obtiene el programa propiamente con sus funcionabilidades y componentes

Pruebas

Conste en realizar pruebas al software creado. Desde ámbitos diferentes para comprobar que de verdad se comporte según lo esperado.

Se empieza probando un programa, posteriormente se prueba como un conjunto de programas, para así conocer si el sistema podría solventar el problema.

Características

Beneficios

Construir un sistema pequeño conlleva menos riesgos que desarrollar un sistema grande.

El usuario se involucra más. Se reduce el tiempo de espera. Al ir desarrollando parte de las funcionabilidades, es más fácil determinar si los

requerimientos planteados para los niveles subsiguientes son correctos. Si un error importante es realizado, solo la última iteración necesita ser

descartada. Reduciendo el tiempo de desarrollo de un sistema decrecen las probabilidades

que esos requerimientos de usuarios puedan cambiar durante el desarrollo. Los errores de desarrollo realizados en un incremento, pueden ser arreglados

antes del próximo incremento. los incrementos se pueden planear para gestionar riesgos técnicos.

Desventajas Se requiere mucha planeación, tanto administrativa como técnica Se requieren metas claras para conocer el estado del proyecto Difícil de evaluar el costo total Las primeras versiones son muy incompletas Se puede aumentar el costo debido a las pruebas ya que pueden requerir más

tiempo y recursos

Modelo Prototipos

Historia Este proceso está en contraste con las décadas de 1960 y 1970 del ciclo de desarrollo monolítica de la construcción de todo el programa primero y luego la elaboración de cualquier inconsistencia entre el diseño y la ejecución, lo que llevó a los mayores costos de software y mal estimaciones de tiempo y costo. Prototipos también puede evitar el gran gasto y la dificultad de cambiar un producto de software terminado.

La práctica de prototipos es uno de los puntos Frederick P. Brooks hizo en su libro de 1975 The Mythical Man-Month y sus 10 años de aniversario artículo No Silver Bullet.

Un ejemplo temprano de prototipos de software a gran escala fue la implementación del traductor Ada / ED que fue creado por la Universidad de Nueva York para el lenguaje de programación Ada. Se llevó a cabo en SETL con la intención de producir un modelo ejecutable para el lenguaje Ada, saltando en la claridad del diseño y la interfaz de usuario a través de la velocidad y la eficiencia.

Concepto

El modelo de prototipos se refiere a la construcción de prototipos de aplicaciones de software que muestran la funcionalidad del producto en fase de desarrollo, pero en realidad no puede contener la lógica exacta del software original/final.

La idea detrás de esto es que un prototipo inicial se presenta al usuario. Ellos proporcionan información y propuestas de mejoras. Están contestado por el desarrollador que a continuación se presenta un prototipo más refinado. El usuario proporciona una vez más retroalimentación. El proceso se repite. Así que en cada etapa el prototipo evoluciona hacia el sistema final. De ahí el término prototipo evolutivo.

La creación de prototipos de software se está volviendo muy popular como un modelo de desarrollo de software, ya que permite entender las necesidades del cliente en una etapa temprana de desarrollo. Ayuda a obtener información valiosa de los clientes y ayuda a los diseñadores y desarrolladores de software a entender acerca de qué es exactamente lo que se espera del producto en fase de desarrollo.

¿Qué es el modelo de prototipos?

- Es un modelo de trabajo de software con algunas funciones limitadas.

- El prototipo no siempre se sostiene la lógica exacta utilizada en la aplicación de software actual/final y es un esfuerzo extra para ser considerado en la estimación de esfuerzo.

- Prototipos se utiliza para permitir que los usuarios evalúen propuestas para desarrolladores y probarlos antes de su implementación.

- También ayuda a entender los requisitos que son específicos del usuario y no pudieron haber sido considerados por el desarrollador durante el diseño del producto.

Desarrollo

A continuación se presenta el enfoque paso a paso para diseñar un prototipo de software:

Requisito básico de identificación: Este paso implica la comprensión de los requisitos más básicos de productos especialmente en términos de interfaz de usuario. Los detalles más intrincados del diseño interno y los aspectos externos, como el rendimiento y la seguridad pueden ser ignorados en esta etapa.

Desarrollar el prototipo inicial: El prototipo inicial se desarrolla en esta etapa, donde los requisitos básicos son exhibidas y las interfaces de usuario se proporcionan. Estas características pueden no funcionar exactamente de la misma manera internamente en el software real desarrollado y las soluciones se utilizan para dar la misma apariencia que el cliente en el prototipo desarrollado.

Revisión del prototipo: El prototipo desarrollado se presenta al cliente y las otras partes interesadas importantes en el proyecto. La retroalimentación se recoge de una manera organizada y se utiliza para nuevas mejoras en el producto en fase de desarrollo.

Revisar y mejorar el Prototipo: La retroalimentación y los comentarios de revisión se discuten en esta etapa y algunas negociaciones suceden con el cliente sobre la base de factores como, el tiempo y las limitaciones presupuestarias y la viabilidad técnica de la implementación real. Los cambios aceptados se incorporan de nuevo en el nuevo prototipo desarrollado y el ciclo se repite hasta que se cumplan las expectativas del cliente.

Los prototipos pueden tener dimensiones horizontales o verticales. Prototipo Horizontal muestra la interfaz de usuario para el producto y da una visión más amplia de todo el sistema, sin concentrarse en las funciones internas. Un prototipo vertical en el otro lado es una elaboración detallada de una función específica o un sistema sub en el producto.

El propósito de ambos prototipo horizontal y vertical es diferente. Prototipos horizontales se utilizan para obtener más información sobre el nivel de interfaz de usuario y los requisitos empresariales. Incluso se puede presentar en las demostraciones de ventas para conseguir que las empresas en el mercado.Prototipos verticales son de carácter técnico y se utilizan para obtener detalles sobre el funcionamiento exacto de los subsistemas. Por ejemplo, los requisitos de base de datos, de interacción y de procesamiento de datos de cargas en un sistema de sub dado.

Etapas

Las fases del modelo evolutivas Prototipos

Este modelo incluye cuatro fases:

La identificación de las necesidades básicas. Aunque es posible que no seamos capaces de saber todos los requisitos, ya que es un proceso continuo, debemos ser capaces de identificar las cosas básicas necesarias para que este proyecto funcione.

Crear el prototipo.Habrá varios prototipos que se harán en este proyecto, con cada uno mejor que el anterior para asegurar su éxito.

Verificación de prototipo. Esto se hará a través de encuestas y participantes de experimentación utilizando tomadas del mercado objetivo. Los clientes son las mejores personas para obtener retroalimentación de averiguar si el sistema es bueno o no.

Los cambios para los prototipos. Cuando descubrió que el prototipo es visto como insuficiente o insatisfactoria, el equipo del proyecto volverá a realizar más iteraciones hasta que se vuelve perfecta, según los comentarios de los clientes.

Características

Ventajas

- Dado que es una serie de iteraciones repetitivas, será fácil para los clientes a ver algunas novedades.

- L obtención de una impresión positiva del mercado es facilmente alcanzable, ya que pueden ver mejoras en el sistema y que brindas mejor servicio al cliente.

- Cuando los sistemas actuales son complicados e ineficaces, este modelo evolutivo se convertirá en un valor incalculable ya que puede allanar el camino para la mejora de los sistemas a través de una serie de iteraciones.

- El proyecto sólo se considera completa una vez que ya es la creación de un sistema perfecto.

Desventajas

- Un problema con el prototipo evolutivo es saber cuándo hay que dejar de ajustar el sistema y, de hecho terminar el desarrollo.

- Con este modelo en particular, puede ser muy difícil de pronosticar la fecha de finalización del proyecto. Se trata de un desarrollo continuo, establecido por el mayor número de iteraciones o prototipos como sea posible que se hace difícil decir cuándo va a ser completa.

- También es importante tener en cuenta que, dado que se trata de un proceso de ensayo y error, sería necesario un buen equipo de gestión del proyecto en términos de conocimientos y habilidades a fin de que sean capaces de contrarrestar sorpresas en el camino.

Comparación entre métodos

Evolutivo contra incremental

El incremental es una aproximación muy parecida a la evolutiva. En este modelo se desarrolla el sistema para satisfacer un subconjunto de los requisitos especificados y en posteriores versiones se incrementa el programa con nuevas funcionalidades que satisfagan más requisitos.

En el caso del modelo evolutivo se desarrollaría una nueva versión de todo el sistema, en el incremental se parte de la versión anterior sin cambios y le añadimos las nuevas funciones.

Diferencias entre el incremental y prototipos

El método evolutivo se diferencia del modelo por prototipos en que en prototipos se da por hecho que aunque se necesiten varias iteraciones para lograrlo al final se llegará a tener una serie de requisitos completos y sin errores, que no vayan a cambiar más.

En el modelo evolutivo se asume que los requisitos pueden cambiar en cualquier momento del ciclo de vida y no solo en la etapa de análisis.

Conclusión

• Un modelo incremental lleva a pensar en un desarrollo modular, con entregas parciales del producto Software denominados ´incrementos´ del sistema, que son escogidos en base a prioridades predefinidas de algún modo.

• El modelo permite unaimplementación con refi-namientos sucesivos (ampliación y/o mejora).

• Con cada incremento se agrega nueva funcionalidad o se cubren nuevos requisitos o bien se mejora la versión previamente implementada del producto software.

• Modelo Prototipo es utilizado básicamente para facilitar a los ingenieros de software el desarrollo de un producto de software mediante la definición de parámetros y requisitos que permitan satisfacer las necesidades del cliente y el usuario además de facilitarle el trabajo al desarrollador.

• Consiste en la representación de un diseño rápido el mismo que me permite establecer incluso el nivel de aceptación que tendrá el software a desarrollarse.

• Modelo Prototipo es fácil de utilizar y de modificar es utilizado para establecer aspectos del sistema que no son contemplados bien mediante la retroalimentación , que consiste en analizar las alternativas y en caso de no cubrir las expectativas del usuario/cliente se procede a repetir las etapas para que el sistema a desarrollar sea de calidad. Administración de Proyectos.

BibliografíaGutierrez, D. (Julio de 2011). Métodos de Desarrollo de Software. (U. d. Andes, Ed.) Obtenido de

http://www.codecompiling.net/files/slides/IS_clase_13_metodos_y_procesos.pdf

Hernandez, A. (7 de 11 de 2013). Modelo incremental - Explicación & Desarrollo. Obtenido de https://www.youtube.com/watch?v=fXMQohgAYAY

Instituto Nacional de Tecnologias de la Comunicacion. (Marzo de 2009). INGENIERÍA DEL SOFTWARE: METODOLOGÍAS Y CICLOS DE VIDA. Obtenido de file:///C:/Users/Felipe/Desktop/guia_de_ingenieria_del_software.pdf

Vennapoosa, C. (16 de 11 de 2012). The Evolutionary Prototyping Model Obtenido dehttp://www.exforsys.com/career-center/project-management-life-cycle/the-evolutionary-prototyping-model.html

Bathia, R. (Agosta 2010). SDLC - Software Prototype Model Obtenido dehttp://www.tutorialspoint.com/sdlc/sdlc_software_prototyping.htm

Jones, D. (Abril 2009) Evolutionary Prototyping Obtenido de http://www.teach-ict.com/as_a2_ict_new/ocr/A2_G063/331_systems_cycle/--(borrar)--prototyping_RAD/miniweb/pg3.htm