Skip to main content
Article thumbnail
Location of Repository

Reengineering Software to Three-tier Applications and Services

By Carlos Manuel Pinto de Matos

Abstract

Driven by the need of a very demanding world, new technology arises as a way to solve problems found in practice. In the context of software, this occurs in the form of new programming paradigms, new application design methodologies, new tool support and new architectural patterns.\ud Newly developed systems can take advantage of recent advances and choose from a state-of-the-art portfolio of techniques, taking stock of an understanding built across the years, learning from past, good and bad, experiences. However, existing software was built in a completely different context.\ud Software engineering advances occur at a very fast pace, and applications are quickly seen as legacy due to a number of reasons, including difficulties to adapt to business needs, lack of integration capabilities with other systems, or general maintenance issues.\ud There are various approaches to address these problems depending on the requirements or major concerns. The solution can either be rewriting the applications from scratch or evolving the existing systems.\ud This thesis presents a methodology for systematically addressing the evolution of existing application into more modern architectures, including proposing implementations to address several classes of modernisation, with particular emphasis in reengineering towards tiered architectures and service-oriented architectures.\ud The methodology is based on a combination of source code pattern detection guiding the extraction of structural graph models, rule-based transformations of these models, and the generation and execution of code-level refactoring scripts to affect the actual changes to the software.\ud This dissertation presents the process, methodology, and tool support. Additionally, the proposed techniques are evaluated in the context of case studies, in order to allow conclusions regarding applicability, scalability, and overall benefits, both in terms of computational and human effort

Publisher: University of Leicester
Year: 2012
OAI identifier: oai:lra.le.ac.uk:2381/10179

Suggested articles

Citations

  1. (2008). A black-box strategy to migrate gui-based legacy systems to web services.
  2. (2008). A case study on software evolution towards service-oriented architecture.
  3. (2003). A comparison of methods for locating features in legacy software.
  4. A frame of reference for soa migration - appendix.
  5. (2010). A frame of reference for soa migration. In ServiceWave,
  6. (2006). A framework for software architecture refactoring using model transformations and semantic annotations.
  7. (2003). A graph grammar approach to software architecture verification and transformation.
  8. (2008). A lightweight approach to partially reuse existing component-based system in serviceoriented environment.
  9. (2008). A wrapping approach for migrating legacy system interactive functionalities to service oriented architectures.
  10. (2005). Alexander Egyed, and Nenad Medvidovic. Improving system understanding via interactive, tailorable, source code analysis.
  11. (1993). An algebraic framework for the transformation of attributed graphs.
  12. (2007). An approach for mining services in database oriented applications.
  13. (2004). An architecture model for dynamically converting components into web services.
  14. (2004). An information retrieval approach to concept location in source code.
  15. (1998). An intermediate representation for reverse engineering analyses.
  16. (1993). An introduction to software architecture.
  17. (2007). Analyzing refactoring dependencies using graph transformation.
  18. (2006). Applying and combining three different aspect mining techniques.
  19. (2003). Automated Cobol to Java recycling.
  20. (1958). Automatic preparation of flow chart listings.
  21. (2000). Case study of feature location using dependence graph.
  22. (2007). Case study: Re-engineering c++ component models via automatic program transformation.
  23. Code Generation Network. List of code generators.
  24. (2006). Combining probabilistic ranking and latent semantic indexing for feature identification.
  25. (2010). Combining termination criteria by isolating deletion.
  26. (2002). Compiling language definitions: the ASF+SDF compiler.
  27. (2008). Composition and customization of web services using wrappers: A formal approach based on csp.
  28. (1963). Computer-drawn flowcharts.
  29. (2003). Creating web services from legacy host programs.
  30. (2002). Data exchange with the columbus schema for c++.
  31. (2002). Design erosion: problems and causes.
  32. (1994). Design Patterns: Elements of Reusable Object-Oriented Languages and Systems.
  33. (2004). DMS R©: Program transformations for practical scalable software evolution.
  34. Eclipse Modeling Framework.
  35. (2009). Eleni Stroulia, and Hani Samir. Legacy systems interaction reengineering.
  36. (1995). Ensuring consistency of conditional graph grammars: A constructive approach.
  37. (2006). Extracting reusable object-oriented legacy code segments with combined formal concept analysis and slicing techniques for service integration.
  38. (2005). Feature analysis for service-oriented reengineering.
  39. (2005). Feature identification: A novel approach and a case study.
  40. (2002). Formalising behaviour preserving program transformations.
  41. (2005). Formalizing refactorings with graph transformations.
  42. From legacy systems to services in the net.
  43. (2006). Fundamentals of Algebraic Graph Transformation.
  44. (1996). Graph processes.
  45. (2006). Graph transformation in a nutshell.
  46. (2002). Graphbased tools for re-engineering.
  47. (2005). Group (OMG). Unified Modeling Language: Superstructure version 2.0. http://www.omg.org/spec/UML/2.0,
  48. (2011). Hype cycle for application architecture,
  49. (2011). Hype cycle for application development,
  50. (1993). Hypergraph rewriting: Critical pairs and undecidability of confluence.
  51. (2004). Identifying aspects using fan-in analysis.
  52. (2006). Identifying use cases in source code.
  53. (1987). Implementing user/computer dialogue in COBOL.
  54. (1990). Indexing by latent semantic analysis.
  55. (2006). Integrating legacy software into a service oriented architecture.
  56. (1940). Lattice theory, volume 25 of Colloquium publications.
  57. (2003). Locating features in source code.
  58. (1992). Locating user functionality in old code.
  59. (2006). Migrating interactive legacy systems to web services.
  60. (2006). Miguel Antunes, Mohammad El-Ramly, and Georgios Koutsoukos. Forms2Net - Migrating Oracle Forms to Microsoft .NET.
  61. (2007). Model-based migration to serviceoriented architectures - a project outline.
  62. (2007). Model-driven service development for a-posteriori application integration.
  63. (2008). Mohammad El-Ramly, Georgios Koutsoukos, and Luis Andrade. Software Evolution, chapter Architectural Transformations: From Legacy to Three-tier and Services,
  64. (2003). Norbik Bashah Idris, and Aziz Deraman. Case study: Reconnaissance techniques to support feature location using recon2.
  65. (2002). ObjectOriented Reengineering Patterns.
  66. (2005). On dynamic feature location.
  67. Organization for the Advancement of Structured Information Standards (OASIS). Reference model for service oriented architecture 1.0.
  68. (1972). Parnas. On the criteria to be used in decomposing systems into modules.
  69. (2006). Partitioning Object-Oriented Source Code for Inspections.
  70. (1996). Patterns for three-tier client/server applications.
  71. (2002). Patterns of Enterprise Application Architecture.
  72. (1981). Program slicing.
  73. (1994). Program understanding and the concept assignment problem.
  74. (2007). Recovering concepts from source code with automated concept identification.
  75. (2008). Reengineering legacy systems with restful web service.
  76. (1999). Refactoring: Improving the Design of Existing Code.
  77. (1998). Requirements for integrating software architecture and reengineering models: CORUM II.
  78. (1990). Reverse engineering and design recovery: A taxonomy.
  79. (2003). Reverse engineering with fuzzy layered graph grammars.
  80. (2006). Semantics-based reverse engineering of object-oriented data models.
  81. (2006). Service extraction.
  82. (2008). Service-oriented architecture overview and guide to SOA research.
  83. (2005). Service-Oriented Architecture: Concepts, Technology, and Design. Prentice Hall PTR, Upper Saddle River,
  84. (2006). Service-oriented design and development methodology.
  85. (2005). Serviceoriented migration and reuse technique (smart).
  86. (2007). Serviceoriented software reengineering: Sosr.
  87. (2004). SNIAFL: Towards a static non-interactive approach to feature location.
  88. (1999). Software architectural transformation.
  89. Software engineering for service-oriented overlay computers.
  90. (1995). Software reconnaissance: mapping program features to code.
  91. (2011). Sorascs: a case study in soa-based platform design for socio-cultural analysis.
  92. (2002). Source transformation in software engineering using the TXL transformation system.
  93. (2005). Static techniques for concept location in objectoriented code.
  94. (2003). Term Rewriting Systems. Cambridge Tracts in Theoretical Computer Science.
  95. The Dagstuhl Middle Model (DMM). http://www.ece.queensu.ca/hpages/courses /elec875/pdf/DMMDescriptionV0006.pdf.
  96. The Eclipse Foundation.
  97. The Open Group. TOGAF - The Open Group Architecture Framework.
  98. (1999). The PROGRES approach: Language and environment.
  99. (2006). Thimios Dimopulos, Christos Tjortjis, and Christos Makris. Mining source code elements for comprehending objectoriented systems and evaluating their maintainability.
  100. (2009). Towards applying model-transformations and -queries for soa-migration.
  101. (2002). Towards pattern-based design recovery. In
  102. UModel UML software development tool.
  103. (2005). Unifying program slicing and concept assignment for higher-level executable source code extraction. Software-Practice and Experience,
  104. (2003). Using grid technologies for webenabling legacy systems.
  105. (1994). Verteilung in betriebswirtschaftlichen anwendungen: Einige bemerkungen von seiten der softwarearchitektur.
  106. (2000). Web-based specification and integration of legacy services.
  107. (2002). What makes good research in software engineering.
  108. (2001). Wins and losses of algebraic transformations of software architectures.
  109. (2005). Wrapping clientserver application to web services for internet computing.
  110. XPath specification.

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.