Legacy Source Code Research Articles

Parglare: A LR/GLR parser for Python

• Deterministic LR parsing. • Generalized GLR parsing. • Integrated scanning. • Declarative disambiguation. • GLR trace visualization. Parglare is a Python parsing library that implements deterministic LR and its generalized extension GLR algorithms. Parglare strives to be easy to use by providing rich error messages, visualization, a CLI tool for grammar development, and good documentation. The same grammar format is used for both algorithms. It is easy to choose either LR parsing if performance is more important or GLR in case a grammar cannot fit into the constraints of deterministic LR parsing and a more powerful parsing is needed. Parglare has been used in data extraction from various textual formats, analysis of legacy source code, and developing and teaching DSL development. The GitHub repository of the project contains multiple examples and a comprehensive functionality and performance test suite.

From Monolith to Microservices: A Semi-Automated Approach for Legacy to Modern Architecture Transition using Static Analysis

Modern system architecture may increase the maintainability of the system and promote the sustainability of the system. Nowadays, more and more organizations are looking towards microservice due to its positive impact on the business which can be translated into delivering quality products to the market faster than ever before. On top of that, native support of DevOps is also desirable. However, transforming legacy system architecture to modern architecture is challenging. As manual modernization is inefficient due to its time-intensive and the significant amount of effort required, the software architect is looking for an automated or semi-automated approach for easy and smooth transformation. Hence, this work proposed a semi-automated approach to transform legacy architecture to modern system architecture based on static analysis techniques. This bottom-up approach utilized legacy source code to adhere to the modern architecture framework. We studied the manual transformation pattern for architectural conversion and explore the possibility of providing transformation rules and guidelines. A task-based experiment was conducted to evaluate the correctness and efficiency of the approach. Two open-source projects were selected and several software architects participated in an architectural transformation task as well as in the survey. We found that the new approach promotes an efficient migration process and produces correct software artifacts with minimum errors rates.

How Long Can We Build It? Ensuring Usability of a Scientific Code Base

Software and in particular source code became an important component of scientific publications and henceforth is now subject of research data management. Maintaining source code such that it remains a usable and a valuable scientific contribution is and remains a huge task. Not all code contributions can be actively maintained forever. Eventually, there will be a significant backlog of legacy source-code. In this article we analyse the requirements for applying the concept of long-term reusability to source code. We use simple case study to identify gaps and provide a technical infrastructure based on emulator to support automated builds of historic software in form of source code.

Non-intrusive subdomain POD-TPWL for reservoir history matching

This paper presents a non-intrusive subdomain POD-TPWL (SD POD-TPWL) for reservoir history matching through integrating domain decomposition (DD), proper orthogonal decomposition (POD), radial basis function (RBF) interpolation, and the trajectory piecewise linearization (TPWL). It is an efficient approach for model reduction and linearization of general non-linear time-dependent dynamical systems without accessing to the legacy source code. In the subdomain POD-TPWL algorithm, firstly, a sequence of snapshots over the entire computational domain is saved and then partitioned into subdomains. From the local sequence of snapshots over each subdomain, a number of local basis vectors is formed using POD, and then the RBF interpolation is used to estimate the derivative matrices for each subdomain. Finally, those derivative matrices are substituted into a POD-TPWL algorithm to form a reduced-order linear model in each subdomain. This reduced-order linear model makes the implementation of the adjoint easy and results in an efficient adjoint-based parameter estimation procedure. Comparisons with the classic finite-difference-based history matching show that our proposed subdomain POD-TPWL approach is obtaining comparable results. The number of full-order model simulations required is roughly 2–3 times the number of uncertain parameters. Using different background parameter realizations, our approach efficiently generates an ensemble of calibrated models without additional full-order model simulations.

A practical approach for detecting multi-tenancy data interference

This paper presents a practical solution for identifying tenant data interference defects when migrating single-tenant legacy code to multi-tenant components or multi-tenant microservices. The paper explains the concepts of multi-tenant components and microservices, elaborates a formal definition of the multi-tenancy data interference problem based on information flow control theory, and presents a practical method to identify potential defects by analysing the code statically. The method has been implemented as a prototype developer support tool for PHP code. The implemented support tool prototype demonstrates the method's effectiveness for supporting the transformation of single-tenant legacy source code into multi-tenant components or microservices. It could also be used to confirm that multi-tenant components or microservices are free of data interference defects. The prototype implementation has been validated in a case study with code from the open-source enterprise application SugarCRM. Results indicate that the developed approach significantly increases the efficiency of multi-tenancy transformation in larger code bases by pointing out potential defects.

Migrating Enterprise Legacy Source Code to Microservices: On Multitenancy, Statefulness, and Data Consistency

Microservice migration is a promising technique to incrementally modernize monolithic legacy enterprise applications and enable them to exploit the benefits of cloud-computing environments. This article elaborates on three challenges of microservice migration: multitenancy, statefulness, and data consistency. The authors show how to identify each of these challenges in legacy code and explain refactoring and architectural pattern-based migration techniques relevant to microservice architectures. They explain how multitenancy enables microservices to be utilized by different organizations with distinctive requirements, why statefulness affects both the availability and reliability of a microservice system, and why data consistency challenges are encountered when migrating legacy code that operates on a centralized data repository to microservices operating on decentralized data repositories. They also explain the interdependencies between multitenancy, statefulness, and data consistency.

Automatic CPU/GPU Generation of Multi-versioned OpenCL Kernels for C++ Scientific Applications

Parallelism has become one of the most extended paradigms used to improve performance. However, it forces software developers to adapt applications and coding mechanisms to exploit the available computing devices. Legacy source code needs to be re-written to take advantage of multi- core and many-core computing devices. Writing parallel applications in a traditional way is hard, expensive, and time consuming. Furthermore, there is often more than one possible transformation or optimization that can be applied to a single piece of legacy code. Therefore many parallel versions of the same original sequential code need to be considered. In this paper, we describe an automatic parallel source code generation workflow (REWORK) for parallel heterogeneous platforms. REWORK automatically identifies promising kernels on legacy C++ source code and generates multiple specific versions of kernels for improving C++ applications, selecting the most adequate version based on both static source code and target platform characteristics.

Software maintenance seen as a knowledge management issue

Creating and maintaining software systems is a knowledge intensive task. One needs to have a good understanding of the application domain, the problem to solve and all its requirements, the software process used, technical details of the programming language(s), the system’s architecture and how the different parts fit together, how the system interacts with its environment, etc. All this knowledge is difficult and costly to gather. It is also difficult to store and usually lives only in the mind of the software engineers who worked on a particular project. If this is a problem for development of new software, it is even more for maintenance, when one must rediscover lost information of an abstract nature from legacy source code among a swarm of unrelated details. In this paper, we submit that this lack of knowledge is one of the prominent problems in software maintenance. To try to solve this problem, we adapted a knowledge extraction technique to the knowledge needs specific to software maintenance. We explain how we explicit the knowledge discovered on a legacy software during maintenance so that it may be recorded for future use. Some applications on industry maintenance projects are reported.

Automating Change Evolution in Model-Driven Engineering

The escalating complexity of software and system models is making it difficult to rapidly explore the effects of a design decision. Automating such exploration with model transformation and aspect-oriented techniques can improve both productivity and model quality. The combination of model transformation and aspect weaving provides a powerful technology for rapidly transforming legacy systems from the high-level properties that models describe. Further, by applying aspect-oriented techniques and program transformation, small changes at the modeling level can trigger very large transformations at the source code level. Thus, model engineers can explore alternative configurations using an aspect weaver targeted for modeling tools and then use the models to generate program transformation rules for adapting legacy source code on a wide scale.

A method for the manual extraction of business rules from legacy source code

One of the main barriers to the successful migration of legacy systems is lack of information about the system to be migrated.With the complexity of modern information systems, it is rarely the case that an organisation has a complete end-to-endunderstanding of its systems, business processes and information. This is particularly true of the business rules enforced by suchsystems, which are often poorly documented (if at all) and incompletely understood by those who own, use and maintain suchsystems. These business rules must be migrated, along with the other system functionality, but this is difficult when they areburied deep within the source code of the system. In this paper, we propose a method for the discovery of business rules throughinspection of the source code of legacy systems. We also describe the results of a comprehensive evaluation exercise undertakenwithin BT, in which the method was applied to a legacy system about to undergo migration. The results of this study indicatedconsiderable success for the method in extracting valid business rules, but also highlighted some weaknesses. Most significantly,the cost of applying the method is a factor of the size and complexity of the system being analysed, and not of the number ofbusiness rules elicited. In order to address this, we propose a cut-down version of the method that can be used to produce a quickestimate of the likely yield of business rules from a program. Together, these two forms of the method aid personnel engaged insystem migration projects in making maximum use of the scarce resources are available for business rule discovery.