**7. Challenges and strategic directions**

Nowadays, software and system engineering industry evolves to manage new platform technologies, design techniques and processes. Architectural frameworks for information integration and tool interoperation, such as MDA, had created the need to develop new analysis tools and specific techniques.

A challenge on reverse engineering is the necessity to achieve co-evolution between different types of software artifacts or different representations of them. MDA allows us to develop and relate all different artifacts in a way that ensures their inter-consistency. MDA raises the level of reasoning to a more abstract level and therefore even more appropriate placing change and evolution in the center of software development process. The integration of business models with PIM, PSMs and code is a crucial challenge in MDA.

Existing formal methods provide a poor support for evolving specifications and incremental verification approaches. In particular, with the existing verification tools, simple changes in a system require to verify its complete specification again making the cost of the verification proportional to its size. To use formal methods that place change and evolution in the center of the software development process is another challenge. The progress in the last decade in scalability and incremental verification of formal methods could impact in MDA reverse engineering processes.

OMG is involved in the definition of standards to successfully modernize existing information systems. Concerning ADM, current work involves building standards to facilitate the exchange of existing systems meta-data for various modernization tools. The main limitations of MDA tools are related to the incipient evolution of MDA standards such as QVT or KDM and to the lack of specification in terms of these standards of various platforms and bridges between platforms.

In summary, a lot remains to be done to provide support for MDA-based software evolution: research on formalisms and theories to increase understanding of software evolution processes; development of methods, techniques and heuristics to provide support for software changes; new verification tools that embrace change and evolution as central in software development processes; development of new sophisticated tools to develop industrial size software systems and definition of standards to evaluate the quality of evolved artifacts/systems.

MDA-Based Reverse Engineering 81

Maoz, S., & Harel, D. (2010) On Tracing Reactive Systems. *Software & System Modeling*. DOI

Martinez, L., Pereira, C., & Favre, L. (2011) Recovering Activity Diagrams from Object-

Milanova, A. (2007). Composition Inference for UML Class Diagrams. *Journal Automated* 

MOF (2006). MOF: Meta Object Facility (MOF ™) 2.0. OMG Specification formal/2006-01-01.

OCL (2010). *OCL: Object Constraint Language. Version 2.2*. OMG: formal/2010-02-01.Retrieved

OCL USE (2011). Retrieved October 2011 from http://www.db.informatik.uni-

OMG (2011). The Object Management Group Consortium. Retrieved October 2011, from

Pereira, C., Martinez, L., & Favre, L. (2011). Recovering Use Case Diagrams from Object-

QVT (2008). QVT: MOF 2.0 Query, View, Transformation. Formal/2008-04-03. Retrieved

Stevens, P. (2008) Bidirectional model transformations in QVT: semantic issues and open

Systa, T. (2000). *Static and Dynamic Reverse Engineering Techniques for Java Software Systems*.

Telea, A., Hoogendorp, H., Ersoy, O. & Reniers, D. (2009). Extraction and visualization of

Tonella, P., & Potrich, A. (2005). Reverse Engineering of Object-oriented Code. *Monographs* 

UML (2010a). *Unified Modeling Language: Infrastructure*. Version 2.3. OMG Specification

UML (2010b). *UML: Unified Modeling Language: Superstructure*. Version 2.3. OMG Specification: formal/2010-05-05. Retrieved October 2011 from www.omg.org USE (2011). Use 3.0. Retrieved October 2011 from http://www.db.informatik.uni-

Ph.D Thesis, University of Tampere, Report A-2000-4.

*in Computer Science*. Heidelberg: Springer-Verlag.

Sommerville, I. (2004). *Software Engineering* (7th ed.). Reading: Addison Wesley.

formal/ 2010-05-03. Retrieved October 2011from www.omg.org.

Oriented Code: an MDA-based Approach. In *Proceedings ITNG 2011, 8th. International Conference on Information Technology: New Generations* (pp. 737-742), Los

questions. Software & Systems Modeling. DOI 10.1007/s10270-008-0109-9,

call dependencies for large C/C++ code bases. In *Proceedings of VISSOFT 2009* (pp.

Medini (2011). Medini QVT. Retrieved October 2011 from http://projects.ikv.de/qvt

Modisco (2011). Retrieved October 2011 from http://www.eclipse.org/Modisco

Oriented Code: an MDA-based Approach. In *Proceedings 2011 International Conference on Software Engineering Research and Practice (SERP 2011)*(Vol. I, pp. 58-

10.1007/510270-010-0151-2, Springer-Verlag.

*Software Engineering.* Vol 14 Issue 2, June.

October 2011 from www.omg.org

Alamitos: IEEE Computer Press.

October 2011 from www.omg.org

19-26) IEEE Computer Press.

bremen.de/projects/USE

bremen.de/projects/USE

www.omg.org

Springer-Verlag

Retrieved October 2011 from www.omg.org/mof

www.omg.org/mda.

64), CSREA Press.

MDA (2005). The Model Driven Architecture. Retrieved October 2011 from

Perhaps, another impediment is the culture change that accompanies this approach. The adoption of reverse engineering techniques in general, should be favored by educating future generations of software engineers, i.e., integrating background on these topics into the computer science curriculum.

#### **8. References**


80 Reverse Engineering – Recent Advances and Applications

Perhaps, another impediment is the culture change that accompanies this approach. The adoption of reverse engineering techniques in general, should be favored by educating future generations of software engineers, i.e., integrating background on these topics into

ADM (2010). Standards Roadmap. ADM Task Force. Retrieved October 2011 from

Aho, A., Sethi, R., & Ullman, J. (1985). *Compilers: Principles, Techniques, and Tools* (2nd ed.).

ANSI-IEEE. (1984). ANSI/IEEE Software Engineering Standards: Std 729-1983, Std 730-1884,

Bidoit, M., & Mosses, P. (2004). *CASL User Manual- Introduction to Using the Common Algebraic Specification Language* (LNCS 2900). Heidelberg: Springer-Verlag. Canfora, G., & Di Penta, M. (2007). New Frontiers of Reverse Engineering. Future of

Chikofsky, E., & Cross, J. (1990). Reverse engineering and design recovery: A taxonomy*.* 

Ernst, M. (2003). Static and Dynamic Analysis: Synergy and duality. In *Proceedings of ICSE* 

Fanta, R., & Rajlich, V. (1998). Reengineering object-oriented code. In *Proceedings of* 

Favre, L. (2005) Foundations for MDA-based Forward Engineering. *Journal of Object* 

Favre, L. (2009). A Formal Foundation for Metamodeling. ADA Europe 2009. *Lecture Notes in Computer Science* (Vol. 5570*,* pp. 177-191). Heidelberg: Springer-Verlag. Favre, L., Martinez, L., & Pereira, C. (2009). MDA-based Reverse Engineering of Object-

Favre, L. (2010). *Model Driven Architecture for Reverse Engineering Technologies: Strategic Directions and System Evolution.* Engineering Science Reference, IGI Global, USA. Jones, N., & Nielson, F. (1995). Abstract interpretation: A semantic based tool for program

KDM (2011). Knowledge Discovery Meta-Model, Version 1.3-beta 2, March 2011. OMG

*Computer Science* (Vol. 4, pp. 527-636). Oxford: Clarendon Press.

specification formal 2010-12-12. Retrieved October 2011 from

http://www.omg.org/spec/kdm/1.3/beta2/pdf

*International Conference on Software Maintenance* (pp. 238-246). Los Alamitos: IEEE

oriented Code. *Lecture Notes in Business Information Processing* (Vol 29, pp. 251-263).

analysis. In D. Gabbay, S. Abramsky, & T. Maibaum (Eds), *Handbook of Logic in* 

Software engineering. In *Proceedings of Future of Software Engineering (FOSE 2007)* 

Std 828-1983, 829-1984, 830-1984. Los Alamitos: IEEE/Wiley.

ATL (2011). ATL Documentation. Retrieved October 2011 from

*www.eclipse.org/m2m/atl/documentation*

(pp. 326-341). Los Alamitos:IEEE Press.

http://www.eclipse.org/emf/

Heidelberg: Springer-Verlag.

Computer Society.

CASE MDA (2011). Retrieved October 2011 from www.case-tools.org

Eclipse (2011). The eclipse modeling framework. Retrieved October 2011 from

*Workshop on Dynamic Analysis (WODA 2003)* (pp. 24-27).

*IEEE Software,* 7(1), 13–17. doi:10.1109/52.43044

*Technology* (JOT), Vol 4, N° 1, Jan/Feb, 129-153.

the computer science curriculum.

adm.omg.org

Reading: Addison-Wesley.

**8. References** 


**4** 

*USA* 

**Reverse Engineering Platform Independent** 

Rama Akkiraju1, Tilak Mitra2 and Usha Thulasiram2

*1IBM T. J. Watson Research Center 2IBM Global Business Services* 

**Models from Business Software Applications** 

The reasons for reverse engineering software applications could be many. These include: to understand the design of the software system to improve it for future iterations, to communicate the design to others when prior documentation is either lost or does not exist or is out-dated, to understand competitors' product to replicate the design, to understand the details to discover patent infringements, to derive the meta model which can then be used to possibly translate the business application on to other platforms. Whatever the reasons, reverse engineering business applications is a tedious and complex technical activity. Reverse engineering a business application is not about analyzing code alone. It requires analysis of various aspects of a business application: the platform on which software runs, the underlying features of the platform that the software leverages, the interaction of a software system with other applications external to the software system being analyzed, the libraries and the components of the programming language as well as application development platforms that the business application uses etc. We argue that this context in which a business application runs is critical to analyzing it and understanding it for whatever end-use the analysis may be put to use. Much of the prior work on reverse engineering in software engineering field has focused on code analysis. Not much attention has been given in literature to understanding the context in which a business application runs from various perspectives such as the ones mentioned above. In our work we address

Modern-day business applications are seldom developed from scratch. For example, they are often developed on higher-level building blocks such as programming language platforms such as J2EE in case of Java programming language and .Net in case of C# programming language. In addition most companies use even higher level application development platforms offered by vendors such as IBM's Websphere and Rational products [18][19], SAP's NetWeaver [20]and Oracles' Enterprise 2.0 software development platforms for Java J2EE application development [21] and Microsoft's .NET platform for C# programming language [22] etc. These platforms offer many in-built capabilities such as web application load balancing, resource pooling, multi-threading, and support for architectural patterns such as service-oriented architecture (SOA). All of these are part of the context in which a business application operates. Understanding this environment is crucial

this specific aspect of reverse engineering business applications.

**1. Introduction** 

Willink, E. (2011). Modeling the OCL Standard Library. *Electronic Communications of the EASST.* Vol. 44. Retrieved October 2011 from http://journal.ub.tu-berlin.de/eceasst/
