Relevant bibliographies by topics / Software re-engineering; Legacy systems

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers
  6. Reports

Academic literature on the topic 'Software re-engineering; Legacy systems'

Author: Grafiati
Published: 4 June 2021
Last updated: 8 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Software re-engineering; Legacy systems.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Software re-engineering; Legacy systems"

1

Guo, Jiang. "Software reuse through re-engineering the legacy systems." Information and Software Technology 45, no. 9 (June 2003): 597–609. http://dx.doi.org/10.1016/s0950-5849(03)00047-8.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

GUO, JIANG, and LUQI. "OBJECT MODELING TO RE-ENGINEER LEGACY SYSTEMS." International Journal of Software Engineering and Knowledge Engineering 10, no. 04 (August 2000): 471–85. http://dx.doi.org/10.1142/s0218194000000225.

Full text
Abstract:
This paper summarizes our experiences in using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. We have analyzed the Janus FORTRAN source code, interviewed Janus domain experts, developed an object-oriented architecture for the Janus Combat Simulation subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the evolution of the software component of these systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.
APA, Harvard, Vancouver, ISO, and other styles
3

Alamin M, Hind, and Hany H. Ammar. "Concerns-Based Reverse Engineering for Partial Software Architecture Visualization." JOIV : International Journal on Informatics Visualization 4, no. 2 (May 26, 2020): 58. http://dx.doi.org/10.30630/joiv.4.2.357.

Full text
Abstract:
Recently, reverse engineering (RE) is becoming one of the essential engineering trends for software evolution and maintenance. RE is used to support the process of analyzing and recapturing the design information in legacy systems or complex systems during the maintenance phase. The major problem stakeholders might face in understanding the architecture of existing software systems is that the knowledge of software architecture information is difficult to obtain because of the size of the system, and the existing architecture document often is missing or does not match the current implementation of the source code. Therefore, much more effort and time are needed from multiple stakeholders such as developers, maintainers and architects for obtaining and re-documenting and visualizing the architecture of a target system from its source code files. The current works is mainly focused on the developer viewpoint. In this paper, we present a RE methodology for visualizing architectural information for multiple stakeholders and viewpoints based on applying the RE process on specific parts of the source code. The process is driven by eliciting stakeholders’ concerns on specific architectural viewpoints to obtain and visualize architectural information related these concerns. Our contributions are three fold: 1- The RE methodology is based on the IEEE 1471 standard for architectural description and supports concerns of stakeholder including the end-user and maintainer; 2- It supports the visualization of a particular part of the target system by providing a visual model of the architectural representation which highlights the main components needed to execute specific functionality of the target system, 3- The methodology also uses architecture styles to organize the visual architecture information. We illustrate the methodology using a case study of a legacy web application system.
APA, Harvard, Vancouver, ISO, and other styles
4

Shaikh, Mohsin, and Chan-Gun Lee. "Aspect Oriented Re-engineering of Legacy Software Using Cross-Cutting Concern Characterization and Significant Code Smells Detection." International Journal of Software Engineering and Knowledge Engineering 26, no. 03 (April 2016): 513–36. http://dx.doi.org/10.1142/s0218194016500212.

Full text
Abstract:
Although object-oriented programming (OOP) methodologies immensely promote reusable and well-factored decomposition of complex source code, legacy software systems often show symptoms of deteriorating design over time due to lack of maintenance. Software systems may have different business and application contexts, but most of these systems require similar maintenance mechanism of understanding, analysis and transformation. As a consequence, intensive re-engineering efforts based on the model driven approach can be effective ensuring that best practices are followed during maintenance and eventually reducing the development cost. In this paper, we suggest detailed framework of re-engineering which includes: (i) rigorous and automated source code analysis technique for identification, characterization and prioritization of most prominent and threatening design flaws in legacy software, (ii) migration of existing the code to aspect-oriented programming (AOP) code by exploiting current state of art for aspect mining mechanism and incorporating behavioral knowledge of cross-cutting concerns. To exemplify how the approach works a case study has been conducted to experimentally validate the idea and analyze the effect of process on specific software quality spectrum. An explicit analysis of prevalent work on the subject and their critical reviews are also presented to further enhance the recognition of proposed re-engineering framework.
APA, Harvard, Vancouver, ISO, and other styles
5

Conejero, José M., Roberto Rodríguez-Echeverría, Fernando Sánchez-Figueroa, Marino Linaje, Juan C. Preciado, and Pedro J. Clemente. "Re-engineering legacy Web applications into RIAs by aligning modernization requirements, patterns and RIA features." Journal of Systems and Software 86, no. 12 (December 2013): 2981–94. http://dx.doi.org/10.1016/j.jss.2013.04.053.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Moraga, Maximiliano, and Yang-Yang Zhao. "Reverse engineering a legacy software in a complex system: A systems engineering approach." INCOSE International Symposium 28, no. 1 (July 2018): 1250–64. http://dx.doi.org/10.1002/j.2334-5837.2018.00546.x.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Schmidt, Frederick, Stephen MacDonell, and Andy M. Connor. "Multi-Objective Reconstruction of Software Architecture." International Journal of Software Engineering and Knowledge Engineering 28, no. 06 (June 2018): 869–92. http://dx.doi.org/10.1142/s0218194018500262.

Full text
Abstract:
Design erosion is a persistent problem within the software engineering discipline. Software designs tend to deteriorate over time and there is a need for tools and techniques that support software architects when dealing with legacy systems. This paper presents an evaluation of a search-based software engineering (SBSE) approach intended to recover high-level architecture designs of software systems by structuring low-level artifacts into high-level architecture artifact configurations. In particular, this paper describes the performance evaluation of a number of metaheuristic search algorithms applied to architecture reconstruction problems with high dimensionality in terms of objectives. These problems have been selected as representative of the typical challenges faced by software architects dealing with legacy systems and the results inform the ongoing development of a software tool that supports the analysis of trade-offs between different reconstructed architectures.
APA, Harvard, Vancouver, ISO, and other styles
8

DONG, JING, YAJING ZHAO, and TU PENG. "A REVIEW OF DESIGN PATTERN MINING TECHNIQUES." International Journal of Software Engineering and Knowledge Engineering 19, no. 06 (September 2009): 823–55. http://dx.doi.org/10.1142/s021819400900443x.

Full text
Abstract:
The quality of a software system highly depends on its architectural design. High quality software systems typically apply expert design experience which has been captured as design patterns. As demonstrated solutions to recurring problems, design patterns help to reuse expert experience in software system design. They have been extensively applied in the industry. Mining the instances of design patterns from the source code of software systems can assist in the understanding of the systems and the process of re-engineering them. More importantly, it also helps to trace back to the original design decisions, which are typically missing in legacy systems. This paper presents a review on current techniques and tools for mining design patterns from source code or design of software systems. We classify different approaches and analyze their results in a comparative study. We also examine the disparity of the discovery results of different approaches and analyze possible reasons with some insight.
APA, Harvard, Vancouver, ISO, and other styles
9

Alkhalil, Adel. "Evolution of existing software to mobile computing platforms: Framework support and case study." International Journal of ADVANCED AND APPLIED SCIENCES 8, no. 3 (March 2021): 100–111. http://dx.doi.org/10.21833/ijaas.2021.03.013.

Full text
Abstract:
Mobile computing as ubiquitous and pervasive technology supports portable and context-aware computation. To date, there exist a significant number of traditional computing systems–running on the web and/or workstation-based platforms–that lack features of mobile computing, including but not limited to ubiquity, context-sensing, and high interactivity. Software that executes on these traditional computing systems is referred to as legacy software that can be upgraded to exploit the features of mobile technologies. However, legacy software may contain critical data, logic, and processes that cannot be easily replaced. One of the solutions is to evolve legacy software systems by (a) upgrading their functionality while (b) preserving their data and logic. Recently research and development efforts are focused on modernizing the legacy systems as per the needs of service and cloud-based platforms. However, there does not exist any research that supports a systematic modernization of legacy software as per the requirements of the mobile platforms. We propose a framework named Legacy-to-Mobile as a solution that supports an incremental and process-driven evolution of the legacy software to mobile computing software. The proposed Legacy-to-Mobile framework unifies the concepts of software reverse engineering (recovering software artifacts) and software change (upgrading software artifacts) to support the legacy evolution. The framework follows an incremental approach with four processes that include (i) evolution planning, (ii) architecture modeling, (iii) architecture change, and (iv) software validation of mobile computing software. The framework provides the foundation (as part of futuristic research) to develop a tool prototype that supports automation and user decision support for incremental and process-driven evolution of legacy software to mobile computing platforms.
APA, Harvard, Vancouver, ISO, and other styles
10

Li, Jing Lei. "Retrieval and Modelling of Software Evolution Process Component." Applied Mechanics and Materials 241-244 (December 2012): 2867–71. http://dx.doi.org/10.4028/www.scientific.net/amm.241-244.2867.

Full text
Abstract:
As more and more successful software systems become legacy systems,the importance and popularity of software evolution increase[1]. In order to make the mature software systems as components, so that they can be re-assembled and maintenance as automobile parts. In this context, the software evolution process component formal definition is designed based on this background. And then define the component model. Based on the questions in component retrieval, faceted classification of the Components and the theory of tree matching algorithm is discussed and analyzed. The Retrieval of Software Evolution Process Component is designed with the theory of tree matching algorithm so as to support the software evolution process modelling.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Software re-engineering; Legacy systems"

1

You, Danyu. "Re-engineering the Legacy Software Systems by using Object-Oriented Technologies." Ohio University / OhioLINK, 2013. http://rave.ohiolink.edu/etdc/view?acc_num=ohiou1386167451.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Williams, Julian R. "Re-engineering and prototyping a legacy software system-Janus version 6.X." Thesis, Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 1999. http://handle.dtic.mil/100.2/ADA361419.

Full text
Abstract:
Thesis (M.S. in Computer Science) Naval Postgraduate School, March 1999.
Thesis advisor(s): Man-Tak Shing, Valdis Berzins. "March 1999". Includes bibliographical references (p. 181-182). Also available online.
APA, Harvard, Vancouver, ISO, and other styles
3

Liu, Xiaodong. "Abstraction : a notion for reverse engineering." Thesis, De Montfort University, 1999. http://hdl.handle.net/2086/4214.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Naspinski, Stan William. "Selection and Implementation of Technologies for the Re-Engineering of an Existing Software System." Scholar Commons, 2011. http://scholarcommons.usf.edu/etd/3260.

Full text
Abstract:
A major hurdle for any company to cross is the act of re-engineering software if they wish to stay relevant. With the speed that software and technology advances, it would be ignorant for any product to stagnate. With that comes the inherent difficulties of choosing which of the older technologies to keep (if any) and which newer technologies to employ in the re-engineered solution. Once that is covered, the actual implementation presents its own set of challenges to both the decision makers and developers in the process. This thesis describes a case study, in particular the efforts put forth to re-engineer some specific software. While the software is quite capable, it is becoming more and more out-dated every passing year, not to mention more difficult to maintain, upgrade and alter, providing a perfect example to explore. The focus of this thesis is to discuss what avenues of upgrading and methods of providing comparable or improved services to the end user our team chose and implemented. These include using a relational database with an advanced object-relational mapper in a modern environment to provide a REpresentational State Transfer (REST) web service that will then supply a rich interactive front-end. Taken together, these tools are quite powerful and capable.
APA, Harvard, Vancouver, ISO, and other styles
5

Waters, Robert Lee. "Obtaining Architectural Descriptions from Legacy Systems: The Architectural Synthesis Process (ASP)." Diss., Available online, Georgia Institute of Technology, 2004:, 2004. http://etd.gatech.edu/theses/available/etd-10272004-160115/unrestricted/waters%5Frobert%5Fl%5F200412%5Fphd.pdf.

Full text
Abstract:
Thesis (Ph. D.)--Computing, Georgia Institute of Technology, 2005.
Rick Kazman, Committee Member ; Colin Potts, Committee Member ; Mike McCracken, Committee Member ; Gregory Abowd, Committee Chair ; Spencer Rugaber, Committee Member. Includes bibliographical references.
APA, Harvard, Vancouver, ISO, and other styles
6

Ewer, John Andrew Clark. "An investigation into the feasibility, problems and benefits of re-engineering a legacy procedural CFD code into an event driven, object oriented system that allows dynamic user interaction." Thesis, University of Greenwich, 2000. http://gala.gre.ac.uk/6165/.

Full text
Abstract:
This research started with questions about how the overall efficiency, reliability and ease-of-use of Computational Fluid Dynamics (CFD) codes could be improved using any available software engineering and Human Computer Interaction (HCI) techniques. Much of this research has been driven by the difficulties experienced by novice CFD users in the area of Fire Field Modelling where the introduction of performance based building regulations have led to a situation where non CFD experts are increasingly making use of CFD techniques, with varying degrees of effectiveness, for safety critical research. Formerly, such modelling has not been helped by the mode of use, high degree of expertise required from the user and the complexity of specifying a simulation case. Many of the early stages of this research were channelled by perceived limitations of the original legacy CFD software that was chosen as a framework for these investigations. These limitations included poor code clarity, bad overall efficiency due to the use of batch mode processing, poor assurance that the final results presented from the CFD code were correct and the requirement for considerable expertise on the part of users. The innovative incremental re-engineering techniques developed to reverse-engineer, re-engineer and improve the internal structure and usability of the software were arrived at as a by-product of the research into overcoming the problems discovered in the legacy software. The incremental reengineering methodology was considered to be of enough importance to warrant inclusion in this thesis. Various HCI techniques were employed to attempt to overcome the efficiency and solution correctness problems. These investigations have demonstrated that the quality, reliability and overall run-time efficiency of CFD software can be significantly improved by the introduction of run-time monitoring and interactive solution control. It should be noted that the re-engineered CFD code is observed to run more slowly than the original FORTRAN legacy code due, mostly, to the changes in calling architecture of the software and differences in compiler optimisation: but, it is argued that the overall effectiveness, reliability and ease-of-use of the prototype software are all greatly improved. Investigations into dynamic solution control (made possible by the open software architecture and the interactive control interface) have demonstrated considerable savings when using solution control optimisation. Such investigations have also demonstrated the potential for improved assurance of correct simulation when compared with the batch mode of processing found in most legacy CFD software. Investigations have also been conducted into the efficiency implications of using unstructured group solvers. These group solvers are a derivation of the simple point-by-point Jaccobi Over Relaxation (JOR) and Successive Over Relaxation (SOR) solvers [CROFT98] and using group solvers allows the computational processing to be more effectively targeted on regions or logical collections of cells that require more intensive computation. Considerable savings have been demonstrated for the use of both static- and dynamic- group membership when using these group solvers for a complex 3-imensional fire modelling scenario. Furthermore the improvements in the system architecture (brought about as a result of software re-engineering) have helped to create an open framework that is both easy to comprehend and extend. This is in spite of the underlying unstructured nature of the simulation mesh with all of the associated complexity that this brings to the data structures. The prototype CFD software framework has recently been used as the core processing module in a commercial Fire Field Modelling product (called "SMARTFIRE" [EWER99-1]). This CFD framework is also being used by researchers to investigate many diverse aspects of CFD technology including Knowledge Based Solution Control, Gaseous and Solid Phase Combustion, Adaptive Meshing and CAD file interpretation for ease of case specification.
APA, Harvard, Vancouver, ISO, and other styles
7

Malinauskienė, Eglė. "Rekonstrukcijos metodų analizė modernizuojant informacinę sistemą." Master's thesis, Lithuanian Academic Libraries Network (LABT), 2004. http://vddb.library.lt/obj/LT-eLABa-0001:E.02~2004~D_20040527_102923-81618.

Full text
Abstract:
This master thesis covers re-engineering methods of legacy systems. Legacy system is an old system, which is hardly compliant with modern technologies and used only because it has become an integral part of organization business process support during the long period of its maintenance. These systems are large, monolithic and difficult to modify, and cost and risk of their replacement are difficult to predict. The science of software engineering offers an incremental modernization of information systems applying the re-engineering of legacy software. The main goal of software re-engineering is to transform the software in the way, it would become easier to understand, maintain and re-use, at the same time preserving its useful, time trusted functions. The main re-engineering methods are source code translation, reverse engineering and data re-engineering. This thesis covers the analysis of these methods, which was made during the re-engineering of wood production and sales accounting system. The adoption and realization time rate of every method was examined. The influence of the applied re-engineering methods to the system reliability, efficiency, usability and other quality metrics is given.
APA, Harvard, Vancouver, ISO, and other styles
8

Braga, Rosana Teresinha Vaccare. "Padrões de software a partir da engenharia reversa de sistemas legados." Universidade de São Paulo, 1998. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-24012001-163455/.

Full text
Abstract:
A execução da engenharia reversa orientada a objetos de um sistema legado desenvolvido com orientação procedimental é usada como base para sua reengenharia, seguindo duas abordagens diferentes. Na primeira, o sistema passa por reengenharia com mudança de orientação, por meio de segmentação e, posteriormente, é transformado para uma linguagem orientada a objetos de forma semi-automática. Na segunda, é feito o reconhecimento de padrões recorrentes de software no modelo de objetos produzido pela engenharia reversa, para depois efetuar a reengenharia utilizando esses padrões. Os resultados obtidos por intermédio dessas duas abordagens podem ser comparados quanto à manutenibilidade, legibilidade e reuso. A versão original do sistema legado escolhido para a realização da experiência está implementado na linguagem Clipper e possui cerca de vinte mil linhas de código. Trata-se de uma oficina auto-elétrica e mecânica de veículos. Para a engenharia reversa foi escolhido o método Fusion/RE, sendo feita uma proposta para sua evolução, adicionando um maior detalhamento da etapa de abstração do modelo de análise do sistema. Para mudança de orientação do paradigma de desenvolviemnto, de procedimental para orientado a objetos, são propostas duas etapas adicionais a serem executadas após a aplicação do Fusion/RE: o projeto avante do sistema e a segmentação do programa legado. Indicações sobre como fazer a segmentação são fornecidas. A transformação do código segmentado em Clipper para Java é feita com auxílio da máquina Draco-Puc. Uma estratégia é proposta para o reconhecimento de padrões a partir do modelo de objetos do sistema obtido pela engenharia reversa. Por meio dela, instâncias dos padrões Type-Object, Association-Object, State Across a Collection e Behaviour Across a Collection podem ser reconhecidas. Experiências de implementação de alguns desses padrões, em Delphi, são feitas.
The object oriented reverse engineering of a legacy system, originally developed using the procedural paradigm, is the basis for two different reengineering approaches. In the first, the reengineering is done to change the implementation paradigm by segmentation, followed by the semi-automatic transformation to an object oriented language. In the second, recurring patterns are first recognized in the object model produced by the reverse engineering, and then the reengineering is done adopting these patterns. Results obtained by these two approaches are compared to assess their maintainability, legibility and reuse. The original version of the legacy system used in this experience has about twenty thousand lines of Clipper code and refers to an electric and mechanic car repair shop. For the reverse engineering phase the Fusion/RE method is used, and a proposal is done for its evolution, adding features to detail its system analysis model abstraction phase. To change the system orientation paradigm, from procedural to object-oriented, two additional phases are proposed to be conducted after the application of the Fusion/RE method: the forward design of the system and the legacy code segmentation. Hints and rationales are supplied to conduct the code segmentaion. The code transformation from segmented Clipper to Java is done with support of the Draco-Puc machine. A strategy is proposed for pattern recognition based on the system object model obtained through reverse engineering. Through it, instances of Type-Object, Association-Object, State Across a Collection and Behaviour Across a Collection patterns can be recognized. Delphi implementation experiments of these patterns are done.
APA, Harvard, Vancouver, ISO, and other styles
9

Nilsson, Simon. "Automated Culling of Data in a Relational Database for Archiving." Thesis, Blekinge Tekniska Högskola, Institutionen för programvaruteknik, 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-18261.

Full text
Abstract:
Background. Archiving of legacy information systems is challenging. When no options exist for extracting the information in a structured way, the last resort is to save the database. Optimally only the information that is relevant should be saved and the rest of the information could be removed. Objectives. The goal is to develop a method for assisting the archivist in the process of culling a database before archiving. The method should be described as rules defining how the tables can be identified.Methods. To get an overview of how the process works today and what archivists think can be improved, a number of interviews with experts in database archiving is done. The results from the interviews are then analysed, together with test databases to define rules that can be used in a general case. The rules are then implemented in a prototype that is tested and evaluated to verify if the method works. Results. The results point to the algorithm being both faster and able to exclude more irrelevant tables than a person could do with the manual method. An algorithm for finding candidate keys has also been improved to decrease the number of tests and execution time in the worst case. Conclusions. The evaluation shows results that point to the method working as intended while resulting in less work for the archivist. More work should be done on this method to improve it further.
APA, Harvard, Vancouver, ISO, and other styles
10

Saffo, Farah, and Basma Saeed. "Modernisering av mjukvaruarkitektur för äldre mjukvarusystem." Thesis, KTH, Hälsoinformatik och logistik, 2021. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-296562.

Full text
Abstract:
Flera företag använder sig än idag av mjukvarusystem som är uppbyggda med äldre mjukvaruarkitektur som den monolitiska. Ett av dessa företag är Consid vars personalsystem är uppbyggt med det utdaterade ramverket klassisk ASP och där användargränssnitt samt logik kan direkt kommunicera med varandra. Detta medför begränsningar som uppstår till följd av brister i modularitet på grund av valet av mjukvaruarkitektur, vilket försvårar vidareutveckling och ändringar i ett system. Dessa begränsningar påverkar i sin tur parametrar som prestanda, skalbarhet, säkerhet, robusthet samt integrering med modernare tekniker.  I denna rapport presenteras en litteraturstudie samt en semistrukturerad intervjustudie, i syfte att undersöka vilka mjukvaruarkitekturer som är lämpliga att implementera vid en modernisering av en monolitisk mjukvaruarkitektur. Arbetet diskuterade också vilka utmaningar som kan uppstå vid en sådan modernisering och hur de hanteras på ett effektivt sätt. Ett bedömningsschema med önskvärda parametrar, med avseende på skalbarhet, prestanda, säkerhet och robusthet, togs fram för att underlätta avgörandet vid val av mjukvaruarkitektur. Utifrån detta, beslutades det att en prototyp med en REST-baserad arkitektur skulle implementeras och utvärderas.  Resultatet av prototypen, till följd av re-architecting, visade en ökad modularisering av mjukvaruarkitekturen. I jämförelse mot med det tidigare systemet har den nya prototypen ingen större påverkan på prestanda i form av responstid. Däremot bidrog prototypen till förbättrad skalbarhet när det gäller vidareutvecklingen av systemet, eftersom det förenklar införandet av ny funktionalitet. Prototypen hade också högre säkerhet genom att isolera lager ifrån varandra samt dölja underliggande detaljer i implementationen. Dessutom blev prototypen inte bara mer robust till följd av modulariseringen, men även enklare att utföra integrationstester samt destruktiva tester mot.
Several companies still use software systems that are built with older software architecture such as the monolithic one. One of these companies is Consid, whose personnel system is built with the outdated framework Classic ASP and where the user interface and logic can directly communicate with each other. This entails limitations that arise because of shortcomings in modularity due to the choice of software architecture, which complicates further development and changes in a system. These limitations in turn, affect parameters such as performance, scalability, security, robustness, and integration with modern technologies. In this work, a literature study was conducted as well as a semi-structured interview study in order to investigate which software architectures are suitable to implement when a modernization of a monolithic software architecture, is carried out. The work also discussed the challenges that may arise in a modernization of the software architecture and how they are handled efficiently. An assessment scheme with desirable parameters regarding scalability, performance, security, and robustness, was developed to facilitate the decision in the choice of software architecture. Based on this, it was decided that a prototype with a REST-based architecture would be implemented and evaluated. The result of the prototype, following re-architecting, showed an increased modularization of the software architecture. Compared to the previous system, the new prototype has no major impact on performance in terms of response time. However, the prototype contributed to better scalability in the further development of the system as it simplifies the introduction of new functionality. The prototype also had higher security by isolating layers from each other and hiding the underlying details in the implementation. In addition, the prototype not only became more robust because of the modularization, but also easier to perform destructive tests against.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Books on the topic "Software re-engineering; Legacy systems"

1

Blunden, Bill. Software Exorcism: A Handbook for Debugging and Optimizing Legacy Code. Berkeley, CA: Apress, 2012.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
2

Rockwell, Rusty. A strategy for upgrading legacy systems using CASE technology. [Atlanta, Ga.]: Information Management Forum, 1998.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
3

Panopoulos, G. Re-engineering of legacy systems using reusable object capsules. Manchester: UMIST, 1995.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
4

Jennings, Charles A. Re-engineering software systems in the Department of Defense using integrated computer aided software engineering tools. Monterey, Calif: Naval Postgraduate School, 1992.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
5

Chicago, Ill ). IEEE International Requirements Engineering Conference (20th 2012. 2012 20th IEEE International Requirements Engineering Conference (RE 2012): Chicago, Illinois, USA, 24-28 September 2012. Piscataway, NJ: IEEE, 2012.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
6

Brazil) IEEE International Requirements Engineering Conference (21st 2013 Rio de Janeiro. 2013 IEEE 21st International Requirements Engineering Conference (RE 2013): Rio de Janeiro, Brazil, 15-19 July 2013. Piscataway, NJ: IEEE, 2013.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
7

IEEE International Requirements Engineering Conference (14th 2006 Minneapolis/St. Paul, Minnesota, USA). 14th IEEE International Requirements Engineering Conference: RE'06 : proceedings : Minneapolis/St. Paul, Minnesota, USA, September 11-15, 2006. Los Alamitos, Calif: IEEE Computer Society, 2005.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
8

Petrinja, Etiel. Open Source Software: Quality Verification: 9th IFIP WG 2.13 International Conference, OSS 2013, Koper-Capodistria, Slovenia, June 25-28, 2013. Proceedings. Berlin, Heidelberg: Springer Berlin Heidelberg, 2013.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
9

F, Radcliffe Mark, ed. Multimedia law and business handbook. Menlo Park, CA: Ladera Press, 1996.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
10

IFIP World Computer Congress (12th 1992 Madrid, Spain). Algorithms, software, architecture: Information processing 92 : proceedings of the IFIP 12th World Computer Congress, Madrid, Spain, 7-11 September 1992. Amsterdam: North-Holland, 1992.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Book chapters on the topic "Software re-engineering; Legacy systems"

1

El-Ramly, Mohammad, Eleni Stroulia, and Hani Samir. "Legacy Systems Interaction Reengineering." In Human-Centered Software Engineering, 316–33. London: Springer London, 2009. http://dx.doi.org/10.1007/978-1-84800-907-3_15.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Kang, Kyo Chul, Moonzoo Kim, Jaejoon Lee, and Byungkil Kim. "Feature-Oriented Re-engineering of Legacy Systems into Product Line Assets – a Case Study." In Software Product Lines, 45–56. Berlin, Heidelberg: Springer Berlin Heidelberg, 2005. http://dx.doi.org/10.1007/11554844_6.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Cho, Eun Sook, Jung Eun Cha, and Young Jong Yang. "MARMI-RE: A Method and Tools for Legacy System Modernization." In Software Engineering Research and Applications, 42–57. Berlin, Heidelberg: Springer Berlin Heidelberg, 2006. http://dx.doi.org/10.1007/11668855_4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

van Deursen, Arie, Paul Klint, and Chris Verhoef. "Research Issues in the Renovation of Legacy Systems." In Fundamental Approaches to Software Engineering, 1–21. Berlin, Heidelberg: Springer Berlin Heidelberg, 1999. http://dx.doi.org/10.1007/978-3-540-49020-3_1.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Georgousopoulos, Christos, Omer F. Rana, and Anthony Karageorgos. "Supporting FIPA Interoperability for Legacy Multi-agent Systems." In Agent-Oriented Software Engineering IV, 167–84. Berlin, Heidelberg: Springer Berlin Heidelberg, 2004. http://dx.doi.org/10.1007/978-3-540-24620-6_12.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Hungar, Hardi, Tiziana Margaria, and Bernhard Steffen. "Model Generation for Legacy Systems." In Radical Innovations of Software and Systems Engineering in the Future, 167–83. Berlin, Heidelberg: Springer Berlin Heidelberg, 2004. http://dx.doi.org/10.1007/978-3-540-24626-8_11.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Dayani-Fard, Homayoun, Yijun Yu, John Mylopoulos, and Periklis Andritsos. "Improving the Build Architecture of Legacy C/C++ Software Systems." In Fundamental Approaches to Software Engineering, 96–110. Berlin, Heidelberg: Springer Berlin Heidelberg, 2005. http://dx.doi.org/10.1007/978-3-540-31984-9_8.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Santoso, Heru-Agus, Su-Cheng Haw, and Chien-Sing Lee. "Software Reuse: MDA-Based Ontology Development to Support Data Access over Legacy Applications." In Software Engineering and Computer Systems, 130–42. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011. http://dx.doi.org/10.1007/978-3-642-22203-0_12.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Book, Matthias, Simon Grapenthin, and Volker Gruhn. "Value-Based Migration of Legacy Data Structures." In Software Quality. Model-Based Approaches for Advanced Software and Systems Engineering, 115–34. Cham: Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-03602-1_8.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Calder, Muffy, Evan Magill, Stephan Reiff-Marganiec, and Vijeyananthan Thayananthan. "Theory and Practice of Enhancing a Legacy Software System." In Systems Engineering for Business Process Change: New Directions, 120–37. London: Springer London, 2002. http://dx.doi.org/10.1007/978-1-4471-0135-2_8.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Software re-engineering; Legacy systems"

1

Zhang, Ji, and Betty H. C. Cheng. "Towards Re-engineering Legacy Systems for Assured Dynamic Adaptation." In International Workshop on Modeling in Software Engineering (MISE'07: ICSE Workshop 2007). IEEE, 2007. http://dx.doi.org/10.1109/mise.2007.14.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Antonini, Canfora, and Cimitile. "Re-engineering legacy systems to meet quality requirements: an experience report." In Proceedings International Conference on Software Maintenance. IEEE Comput. Soc. Press, 1994. http://dx.doi.org/10.1109/icsm.1994.336780.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Khodabandehloo, Hamid, Banani Roy, Manishankar Mondal, Chanchal Roy, and Kevin Schneider. "A Testing Approach While Re-engineering Legacy Systems: An Industrial Case Study." In 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 2021. http://dx.doi.org/10.1109/saner50967.2021.00073.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Cherukupalli, Prabhakar, and Y. Raghu Reddy. "Reengineering Enterprise Wide Legacy BFSI Systems." In ISEC '15: 8th India Software Engineering Conference. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2723742.2723746.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

de Lima Justino, Yan, and Carlos Eduardo da Silva. "Reengineering legacy systems for supporting SOA." In ICSE '18: 40th International Conference on Software Engineering. New York, NY, USA: ACM, 2018. http://dx.doi.org/10.1145/3183440.3195067.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Wolfart, Daniele, Wesley K. G. Assunção, Ivonei F. da Silva, Diogo C. P. Domingos, Ederson Schmeing, Guilherme L. Donin Villaca, and Diogo do N. Paza. "Modernizing Legacy Systems with Microservices: A Roadmap." In EASE 2021: Evaluation and Assessment in Software Engineering. New York, NY, USA: ACM, 2021. http://dx.doi.org/10.1145/3463274.3463334.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Hall, R. J. "Upgrading legacy instances of reactive systems." In Proceedings of ASE 2000 15th IEEE International Automated Software Engineering Conference. IEEE, 2000. http://dx.doi.org/10.1109/ase.2000.873651.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Turner, Cameron J., John M. MacDonald, and Jane A. Lloyd. "Software Archeology: A Case Study in Software Quality Assurance and Design." In ASME 2009 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference. ASMEDC, 2009. http://dx.doi.org/10.1115/detc2009-86776.

Full text
Abstract:
Ideally, quality is designed into software, just as quality is designed into hardware. However, when dealing with legacy systems, demonstrating that the software meets required quality standards may be difficult to achieve. Evolving customer needs, expressed by new operational requirements, resulted in the need to develop a legacy software quality assurance program at Los Alamos National Laboratory (LANL). This need led to the development of a reverse engineering approach referred to as software archaeology. This paper documents the software archaeology approaches used at LANL to demonstrate the software quality in legacy software systems. A case study for the Robotic Integrated Packaging System (RIPS) software is included to describe our approach.
APA, Harvard, Vancouver, ISO, and other styles
9

Mortensen, Michael, Sudipto Ghosh, and James Bieman. "Testing During Refactoring: Adding Aspects to Legacy Systems." In 2006 17th International Symposium on Software Reliability Engineering. IEEE, 2006. http://dx.doi.org/10.1109/issre.2006.46.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Jin, Yan, Antony Tang, Jun Han, and Yan Liu. "Performance Evaluation and Prediction for Legacy Information Systems." In 29th International Conference on Software Engineering (ICSE'07). IEEE, 2007. http://dx.doi.org/10.1109/icse.2007.64.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Reports on the topic "Software re-engineering; Legacy systems"

1

Clark, Peter G., and John A. Gill. Legacy Software Re-Engineering Technology (LSRET). Fort Belvoir, VA: Defense Technical Information Center, April 1998. http://dx.doi.org/10.21236/ada388217.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Software re-engineering; Legacy systems' for particular source types:
Journal articles Dissertations / Theses Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography