Propuesta de investigación.

“Modelado de secuencia lógica que permite la transformación de diagramas de secuencia a código de programación java”

Presentado por

Héctor Iván Blanco Rodríguez.

MCIC - Facultad de ingeniería.

Universidad Francisco José de Caldas

Bogota D.C

Tabla de contenido

1. TITULO DEL PROYECTO....................................................................................................1

2. LÍNEA DE INVESTIGACIÓN................................................................................................1

3. RESUMEN DEL PROYECTO...............................................................................................1

4. PRESENTACIÓN DE LA PROPUESTA.................................................................................1

4.1. FORMULACIÓN DEL PROBLEMA...................................................................................1

4.1.1. JUSTIFICACIÓN.........................................................................................................2

4.1.2. ANTECEDENTES.......................................................................................................3

4.1.3. INTERROGANTE........................................................................................................4

4.2. MARCO TEÓRICO O CONCEPTUAL...............................................................................4

4.3. OBJETIVOS...................................................................................................................6

4.3.1. OBJETIVO GENERAL.................................................................................................6

4.3.2. OBJETIVOS ESPECIFICOS.........................................................................................6

4.4. MARCO METODOLÓGICO..............................................................................................7

4.4.1. GENERAL..................................................................................................................7

4.4.2. ESPECÍFICO..............................................................................................................7

4.5. HIPOTESÍS....................................................................................................................8

4.6. BIBLIOGRAFÍA...............................................................................................................8

4.7. CRONOGRAMA.............................................................................................................9

4.8. ANEXOS........................................................................................................................9

5. RESULTADOS E IMPACTO ESPERADO..............................................................................9

6. COMUNICACIÓN Y DIVULGACIÓN...................................................................................10

1. TITULO DEL PROYECTO

Modelado de una secuencia lógica que permite la transformación de diagramas de secuencia a código de programación java.

2. LÍNEA DE INVESTIGACIÓN

Ingeniería de software.

3. RESUMEN DEL PROYECTO

El desarrollo de software es una práctica que permite modelar el comportamiento de un software en donde actualmente se utiliza UML, siendo este un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. Sin embargo no siempre resulta fácil transformar este lenguaje grafico a código de programación, haciendo que muchas veces no sea claro el cómo podemos hacer este ejercicio debido a que UML presenta distintos diagramas que permiten interpretar de varias maneras el comportamiento del software, para ello el presente proyecto pretende modelar una secuencia lógica que mediante el modelado de UML 2.0 permite la obtención de código fuente en JAVA, ya que este código de programación es uno de los más utilizados en la actualidad para la ejecución de los programas sobre las máquinas de computación y que utiliza el paradigma orientado a objetos.

Utilizando la metodología RUP (Rational Unified Process) que es un proceso de software de desarrollo que define claramente, quien, cómo, cuándo y que debe hacerse en el proyecto a desarrolla y la metodología de investigación documental se dará solución a los objetivos de la investigación, que tiene como propósito aumentar el conocimiento en cuanto a las ciencias de la ingeniería, específicamente Ingeniería de software y formar una base que pueda aportar a nuevas investigaciones en el futuro.

Un modelado de secuencia lógica que permite la transformación de diagramas de secuencia a código de programación java es el resultado esperado de la investigación, el cual tendrá un importante impacto en la comunidad que estudia ingeniería de software, ya que se convierte en una referencia bibliográfica importante a la hora de estudiar UML combinado con el código de programación JAVA. Adicional se pueden generar herramientas de software que utilicen esta secuencia como medio de comprobaciones académicas e incluso a la hora de desarrollar proyectos de ingeniería de forma profesional.

1 | P á g i n a

4. PRESENTACIÓN DE LA PROPUESTA

4.1. FORMULACIÓN DEL PROBLEMA

4.1.1. JUSTIFICACIÓN

En la actualidad la idea modelar software es bastante común, sin embargo muchas veces nos vemos enfrentados con la imposibilidad de poder pasar de un lenguaje de modelado como lo es UML a un lenguaje de programación, ya que estos dos conceptos son distintos. Primero debemos familiarizaros con el concepto de lenguaje de modelado, el cual de manera gráfica nos permite visualizar, especificar, construir y documentar un sistema de software, desde los requerimientos del cliente hasta el modelado final del programa. En cuanto al lenguaje de programación, es un lenguaje formal compuesto de un conjunto de símbolos dey reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones, está diseñado para expresar procesos que pueden ser llevados a cabo por máquinas como las computadoras.

Ahora bien, si los conceptos de Leguaje de modelado y lenguaje de programación son distintos, deben existir algunas reglas que me permita moverme entre estos dos tipos de lenguaje, o su equivalente en ambos lenguajes, es por ellos que la desarrollar una secuencia lógica que mediante el modelado de UML 2.0 permite la obtención de código fuente en JAVA, se pude llegar a tener un sistema de referencia para poder pasar entre lenguajes de modelado y lenguajes de programación.

Herramientas como modelado UML como Enterprise Architecture ya tiene una estructura definida para esta situación particular, sin embargó muchas veces no tenemos esta herramienta por lo cual desarrollar una serie de pasos lógicos de transformación nos permitirá Generar un modelo que nos permite realizar esta transformación de forma sistemática.

4.1.2. ANTECEDENTES

Ya se han realizado varias publicaciones a que tienen en cuenta la trasformación de distintos diagramas de UML hacia código de programación en Java y otros más que tratan de ingeniería inversa, es decir transformado el código fuente a diagramas de UML, es decir actualmente solo se encuentran estos dos escenarios en el mundo de software, como lo es la transformación de un modelo de software basado en UML y pasarlo a código de programación, o el caso

2 | P á g i n a

contrario cuando hacemos ingeniería inversa, es decir pasar de un código fuente (java) al lenguaje de modelado unificado (UML), este último escenario se presenta frecuentemente cuando se desea realizar mantenimiento a un software que no está debidamente documentado [1].

Entre los diversos artículos expuestos por otros autores, encontramos otra particularidad, y el lenguaje de programación JAVA, ya que por portabilidad (Multiplataforma) se ha convertido en uno de los más utilizados, adicional es un lenguaje que aborda el paradigma de la orientación a objetos, es por ello que los anteriores artículos relacionan este lenguaje de programación.

Teniendo en cuenta que los diagramas de UML son bastantes, se presentan dos casos interesantes a la hora de realizar la transformación de diagramas UML a código de programación en JAVA, y el analizar si se va a realizar desde la perspectiva de los aspectos estáticos (Diagramas de Clase, Componentes, objetos) o los aspectos dinámicos (Casos de Uso, Diagrama de actividades, Diagramas de colaboración y diagramas de Secuencia), los que actualmente que describen un método de transformación de UML a código JAVA relación únicamente los aspectos dinámicos, ya que son básicamente la representación gráfica de como interactúa el sistema, es por ello encontramos artículos que relacionan los Casos de Usos [2] y los Diagramas de Secuencia [3] para la transformación a código en JAVA.

4.1.3. INTERROGANTE

¿Cuál es la secuencia lógica que mediante el modelado de UML 2.0 en diagramas de secuencia permite la obtención de código fuente en JAVA?

4.2. MARCO TEÓRICO O CONCEPTUAL (Estar claras las variables de investigación y establecer su interrelación si son dependientes o independientes)

UML está respaldado por la OMG1 y sus inicios se remonta a la década de los 90, cuando Rational Software Corporation contratara a James Rumbaugh de General Electric en 1994 la compañía se convirtió en la fuente de los dos esquemas de modelado orientado a objetos más populares de la época: el OMT (Object-modeling technique) de Rumbaugh, que era mejor para análisis orientado a objetos, y el Método Booch de

1 OMG (Object Management Group) es un consorcio dedicado al cuidado y el establecimiento de diversos estándares de tecnologías orientadas a objetos, tales como UML, XMI, CORBA

3 | P á g i n a

Grady Booch, que era mejor para el diseño orientado a objetos. Poco después se les unió Ivar Jacobson, el creador del método de ingenieríá de software orientado a objetos. Jacobson se unió a Rational en 1995 después de que su compañía, Objectory AB, fuera comprada por Rational. Los tres metodologistas eran conocidos como los Tres Amigos, porque se sabía de sus constantes discusiones sobre las prácticas metodológicas.

En 1996 Rational concluyó que la abundancia de lenguajes de modelado estaba alentando la adopción de la tecnología de objetos, y para orientarse hacia un método unificado, encargaron a los Tres Amigos que desarrollaran un Lenguaje Unificado de Modelado abierto. Se consultó con representantes de compañías competidoras en el área de la tecnología de objetos durante la OOPSLA '96; eligieron cajas para representar clases en lugar de la notación de Booch que utilizaba símbolos de nubes.

Bajo la dirección técnica de los Tres Amigos fue organizado un consorcio internacional llamado UML Partners en 1996 para completar las especificaciones del Lenguaje Unificado de Modelado (UML), y para proponerlo como una respuesta al OMG RFP. El borrador de la especificación UML 1.0 de UML Partners fue propuesto a la OMG en enero de 1997. Durante el mismo mes la UML Partners formó una Fuerza de Tarea Semántica, encabezada por Cris Kobryn y administrada por Ed Eykholt, para finalizar las semánticas de la especificación y para integrarla con otros esfuerzos de estandarización. El resultado de este trabajo, el UML 1.1, fue presentado ante la OMG en agosto de 1997 y adoptado por la OMG en noviembre de 1997 [4].

Como resultado del trabajo de los tres amigos, surgió la primera versión UML denominada UMLL 1.0 Actualmente se trabaja en la versio de de UML 2.5 la cual fue lanzada en octubre del 2012.

Para continuar hablando de UML ya que es un estándar respaldado por al OGC, es necesario describir que son los diagrama de secuencia hincapié en el orden de tiempo de los mensajes. Un diagrama de secuencia muestra un conjunto de objetos y los mensajes enviados y recibidos por esos objetos. Los objetos se suelen llamar o casos anónimos de clases, pero también pueden representar instancias de otras cosas, tales como colaboraciones, componentes y nodos. Se suele utilizar los diagramas de secuencia para ilustrar la visión dinámica de un sistema [5].

4 | P á g i n a

Figura 1. Diagrama de secuencia.

JAVA es un lenguaje de programación desarrollado por un grupo de ingenieros de Sum Microsystems liderado por James Gosling que se deriva de otros lenguajes de programación como C2 y C++3, convirtiéndose en lenguaje de programación de propósito general, concurrente, orientado a objetos y basado en clases que fue diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible.

Figura 2. Código escrito en JAVA.

2 C es un lenguaje de programación creado por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B y es apreciado por la eficiencia del código que produce y es el lenguaje de programación más popular para crear software de sistemas3 C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos

5 | P á g i n a

En consecuencia los diagramas de UML deben tienen una relación directa con los lenguajes de programación ya que UML es una forma de representar gráficamente lo que el código de programación ejecuta en la máquina de computación, sin embargo a simple vista no se ve cual es el método que se debe seguir para realizar esta transformación, es por esto que aquí en este punto se sitúa el foco principal de a investigación, en encontrar algún método que relacione de forma directa a UML con el código de programación JAVA.

4.3. OBJETIVOS

4.3.1. OBJETIVO GENERAL

Modelar una secuencia lógica que mediante el modelado de UML 2.0 en diagramas de secuencia que permite la obtención de código fuente JAVA.

4.3.2. OBJETIVOS ESPECIFICOS

Identificar cuáles son los parámetros de modelado en diagramas de secuencia UML 2.0.

Identificar la semántica de los distintos elementos que conforman un diagrama de secuencia de UML 2.0.

Determinar cómo es la estructura de la programación en JAVA. Definir cuáles son los requerimientos de diseño necesarios para la

transformación de los diagramas de secuencia UML 2.0 a código de programación JAVA.

Obtener las equivalencias entre la estructura de los diagramas de secuencia UML y el código de programación JAVA.

Definir las reglas de conversión de los diagramas de secuencia UML a código de programación JAVA, para identificar la secuencia lógica.

Desarrollar un prototipo de software que permita verificar la secuencia a de conversión de los diagramas de secuencia UML 2.0 a código de programación JAVA.

4.4. MARCO METODOLÓGICO

El presente marco metodológico describe cual va a ser la metodóloga para lograr dar solución a los objetivos propuestos que pretender dar solución a la pregunta de investigación propuesta

6 | P á g i n a

4.4.1. GENERAL

La modalidad de investigación es de carácter documental, ya que se pretende ampliar y profundizar los conocimientos debido a las revisiones criticas del estado del conocimiento: integración, organización y evaluación de la información teórica y empírica existente sobre el problema, focalizado ya sea en el progreso de la investigación actual y posibles vías para su solución, en el análisis de la consistencia interna y externas de las teorías y conceptualizaciones para señalar sus fallas o demostrar la superioridad de unas sobre otras, o en ambos aspectos.

La investigación documental “es un proceso basado en la búsqueda, recuperación, análisis, crítica e interpretación de datos secundarios, es decir, los obtenidos y registrados por los otros investigadores en fuentes documentales: impresas, audiovisuales o electrónicas. Como en toda investigación, el propósito de este diseño es el aporte de nuevos conocimientos”4

4.4.2. ESPECÍFICO

La metodología que se utilizó para este sistema fue RUP (Rational Unified Process); ya que es un proceso de software de desarrollo que define claramente, quien, cómo, cuándo y que debe hacerse en el proyecto a desarrollar. Entre sus características esenciales tenemos es que es orientado por los casos de uso (UML); estos conducen el proyecto a la importancia del usuario y a lo que este quiere, centrándose en la arquitectura. De esta manera se relaciona con la toma de decisiones que indican cómo debe estar estructurado el sistema y en qué orden. Se considera iterativo incremental ya que se divide en mini proyectos donde los casos de usos y la organización cumplen sus objetivos de forma depurada.

Etapas en RUP.

Marco iterativo del proceso de desarrollo del software. No es un solo proceso rígido, sino algo un marco de procesos adaptable, previsto para ser ajustado por los equipos de proyecto de las organizaciones y los equipos de desarrollo de software que seleccionarán los elementos del proceso que son apropiados para sus necesidades.

4 Arias, Fidias (2006). El proyecto de investigación: Introducción a la metodología científica. (5º. ed.)

7 | P á g i n a

Para usar RUP generalmente se define (o se escoge) un caso de desarrollo, que es una instancia de RUP o un proceso dentro del marco general.

RUP es esencialmente un proceso iterativo y se divide en cuatro fases:

Concepción: Evaluación inicial del proyecto. Elaboración: Identifica casos de uso primarios y define

iteraciones. Permite conocer bien el problema a resolver. Construcción: Desarrolla suficientes funcionalidades para

producir una primera versión del modelo o software. Transición: Actividades finales que generalmente no se realizan

de forma iterativa. Implantación, entrenamiento de usuarios, etc.

En los anexos se puede consultar el cronograma con los pasos y tiempos estimados para la culminación del proyecto de investigación.

4.5. HIPOTESÍS

La transformación de diagramas de secuencia en UML 2.0 a código de programación JAVA que emplea una secuencia lógica y funcional se convierte en un modelo de referencia y consulta para el estudio de ingeniería de software.

4.6. BIBLIOGRAFÍA

[1] Carlos Mario Zapata, Óscar Andrés Ochoa, Camilo Vélez. “Un metodo de ingenieria inversa de codigo java hacia diagramas de secuencia UML”. Revista EIA, ISSN 1794-1237 Número 9, p. 31-42. Julio 2008.Escuela de Ingeniería de Antioquia, Medellín (Colombia).

[2] Michał Śmiałek, Norbert Jarzębowski, Wiktor Nowakowski. “Traslation Of Use Case Escenarios to java Code” Computer Science • 13 (4) 2012.

[3] De Castro V., Marcos E., Vara J. M.: Applying CIM-to-PIM model transformations for the service-oriented development of information systems. Information and Software Technology, 53:87–105, 2011

[4] James Rumbaugh, Ivar Jacobson, Grady Booch. The Unified Modeling Languge Reference Manual – Second Esition.

[5] James Rumbaugh, Ivar Jacobson, Grady Booch. Unified Modeling Language User Guide.

[6] Pornsiri Muenchaisri, Mathupayas Thongmak. “Design of Rules for Transforming UML Sequence Diagrams into Java code”, Chulalongkorn University.

[7] Gregor Engels, Roland Hucking, Stefan Sauer and Annika Wagner. “UML Collaboration Diagrams and Their Transformation to Java”,

8 | P á g i n a

Second International Conference on the Unified Modeling Language (UML’ 99), pp. 437-488, 1999.

[8] Neeraj Sangal, Edward Ferrel, Karl Lieberherr and David Lorenz. “Interaction Schemata: Compiling Interactions to Code”, the proceedings of Technology of Object-Oriented Language and Systems (TOOLS USA’ 99), pp. 268-277, 1999

[9] Dong Hyuk Park, Soo Dong Kim. “XML Rule Based Source Code Generator for UML Case Tool”, Asia-Pacific Software Engineering Conference (APSEC2001), pp. 53-60, 2001.

[10] Yuebo Liu, Haitao Yu.The Denotational Semantics-Based Formalized sequence diagrams. 2012.

[11] Ming Li, Yanrui Ruan. Approach to Formalizing UML Sequence Diagrams. 2011

[12] Dinh-Phuc Nguyen, Chung-Tuyen Luu, Ninh-Thuan Truong, Radics, N. Verifying Implementation of UML Sequence Diagrams Using Java PathFinder. 2010.

[13] Faria, J.P. , Paiva, A.C.R. , Zhuanli Yang.Test Generation from UML Sequence Diagrams. 2010.

[14] Parada, A.G. ; Siegert, E. ; de Brisolara, L.B. Generating Java Code from UML Class and Sequence Diagrams. 2011.

[15] Meixia Zhu, Hanpin Wang, Wei Jin, Zizhen Wang, Chunxiang Xu. Semantic Analysis of UML2.0 Sequence Diagram Based on Model Transformation

[16] Ilham, A.A, Murakami, K. Evaluation and optimization of Java object ordering schemes. 2011.

[17] Lunjin Lu, Dae-Kyoo Kim. Required Behavior of Sequence Diagrams: Semantics and Refinement. 2011.

4.7. CRONOGRAMA

El cronograma del proyecto de investigación se puede evidenciar en el anexo No 1, el cual indica el tiempo estimado para cada una de las actividades que darán solución a los objetivos de la propuesta de investigación.

4.8. ANEXOS

Anexo 1 - Diagrama Gantt del proyecto de investigación.

9 | P á g i n a

5. RESULTADOS E IMPACTO ESPERADO

Al concluir la investigación se espera que el resultado tenga un impacto inicial en la comunidad académica de la Universidad Distrital Francisco José de Caldas en los siguientes aspectos:

a. Generación de conocimiento: Se crea un modelo que puede servir para generar nuevo conocimiento en cuanto a ingeniería de software.

b. Nuevos desarrollos tecnológicos: Con la implementación del modelo desarrollado, se puede desarrollar una aplicación de prueba y de carácter educativo para la Universidad Distrital Francisco José de Caldas

c. Fortalecimiento de la capacidad científica: Este modelo servirá para futuras investigaciones, como por ejemplo como optimizarlo, o en dado caso realizar el proceso inverso teniendo la capacidad de servir como soporte científico para otras investigaciones.

d. Fortalecimiento de la capacidad institucional: Se publicara en la revista de la Universidad Distrital Francisco José de Caldas, esto llevara a que otras entidades educativas puedan consultar el resultado de esta investigación haciendo que la universidad obtenga mayor prestigio de carácter investigativo.

6. COMUNICACIÓN Y DIVULGACIÓN

Los resultados serán publicados en la revista de la Universidad Distrital Francisco José de Caldas, lo cual garantiza acceso a esta materia por parte del estudiantado no solamente de esta universidad sino de otras que ofrezcan programas relacionados con ingeniería de software. Adicional, al ser materia de conocimiento público, puede ser utilizado para la implementación de alguna herramienta profesional siempre y cuando se pida consentimiento al autor.

10 | P á g i n a