Aspect Oriented Re-engineering of Legacy Software Using Cross-Cutting Concern Characterization and Significant Code Smells Detection

2016 ◽  
Vol 26 (03) ◽  
pp. 513-536
Author(s):  
Mohsin Shaikh ◽  
Chan-Gun Lee
Keyword(s):  
Source Code ◽  
Object Oriented Programming ◽  
Software Systems ◽  
Aspect Mining ◽  
Legacy Software ◽  
Model Driven ◽  
Current State ◽  
Analysis Technique ◽  
Explicit Analysis ◽  
Model Driven Approach

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.

scholarly journals Extracting Interactive Actor-Based Dataflow Models from Legacy C Code

2021 ◽  
pp. 361-377
Author(s):  
Niklas Rentz ◽  
Steven Smyth ◽  
Lewe Andersen ◽  
Reinhard von Hanxleden
Keyword(s):  
Large Fraction ◽  
Source Code ◽  
Software Systems ◽  
Team Members ◽  
C Language ◽  
Legacy Software ◽  
Model Driven ◽  
Visual Models ◽  
High Level ◽  
Dataflow Models

AbstractGraphical actor-based models provide an abstract overview of the flow of data in a system. They are well-established for the model-driven engineering (MDE) of complex software systems and are supported by numerous commercial and academic tools, such as Simulink, LabVIEW or Ptolemy. In MDE, engineers concentrate on constructing and simulating such models, before application code (or at least a large fraction thereof) is synthesized automatically. However, a significant fraction of today’s legacy system has been coded directly, often using the C language. High-level models that give a quick, accurate overview of how components interact are often out of date or do not exist. This makes it challenging to maintain or extend legacy software, in particular for new team members.To address this problem, we here propose to reverse the classic synthesis path of MDE and to synthesize actor-based dataflow models automatically from source code. Here functions in the code get synthesized into nodes that represent actors manipulating data. Second, we propose to harness the modeling-pragmatic approach, which considers visual models not as static artefacts, but allows interactive, flexible views that also link back to textual descriptions. Thus we propose to synthesize actor models that can vary in level of detail and that allow navigation in the source code. To validate and evaluate our proposals, we implemented these concepts for C analysis in the open source, Eclipse-based KIELER project and conducted a small survey.

Pair Modeling

2010 ◽  
pp. 1171-1178 ◽  
Author(s):  
Pankaj Kamthan
Keyword(s):  
Software Development ◽  
Software Process ◽  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

We model software for a variety of reasons: to assess the viability of or plan software systems to be built, to optimize use of (minimize, or ideally, avoid waste of) resources in response to inevitable changes in business, social, or technological environments, or simply to understand existing software systems. Indeed, as indicated by the model-driven approach to software development (Beydeda, Book, & Gruhn, 2005), models are becoming first-class members of organizations and software process environments that embrace them. The examples of collaboration in implementation of software are well-known (Nosek, 1998; Williams & Kessler, 2003). As models get large and complex, the need for creating them collaboratively in a systematic manner arises, and we propose pair modeling as an approach.

A Model-driven Approach to Aspect Mining

2006 ◽  
Vol 5 (3) ◽  
pp. 573-576
Author(s):  
Bounour Nora ◽  
Ghoul Said
Keyword(s):  
Aspect Mining ◽  
Model Driven ◽  
Model Driven Approach

A model-driven approach for the generation of configurations for highly available software systems

2018 ◽  
Vol 14 (4) ◽  
pp. 273-307 ◽  
Author(s):  
Pejman Salehi ◽  
Abdelwahab Hamou-Lhadj ◽  
Maria Toeroe ◽  
Ferhat Khendek
Keyword(s):  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

Reducing the Complexity of Modeling Large Software Systems

2009 ◽  
pp. 3399-3429
Author(s):  
Jules White ◽  
Douglas C. Schmidt ◽  
Andrey Nechypurenko ◽  
Egon Wuchner
Keyword(s):  
Constraint Satisfaction ◽  
Constraint Satisfaction Problems ◽  
Correct Solution ◽  
Software Systems ◽  
Domain Expert ◽  
Modeling Tool ◽  
Constraint Solver ◽  
Model Driven ◽  
Model Driven Approach ◽  
Domain Constraints

Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows designers to use domain notations to specify solutions and domain constraints to ensure that the proposed solutions meet the required objectives. Many domains, however, require models that are either so large or intricately constrained that it is extremely difficult to manually specify a correct solution. This chapter presents an approach to provide that leverages a constraint solver to provide modeling guidance to a domain expert. The chapter presents both a practical framework for transforming models into constraint satisfaction problems and shows how the Command Pattern can be used to integrate a constraint solver into a modeling tool.

REDESIGNING LEGACY SYSTEMS INTO THE OBJECT-ORIENTED PARADIGM

2004 ◽  
Vol 14 (03) ◽  
pp. 255-276
Author(s):  
W. ERIC WONG ◽  
JENNY LI
Keyword(s):  
Inventory Management ◽  
Source Code ◽  
Object Oriented ◽  
Original System ◽  
Software Systems ◽  
Legacy Systems ◽  
Dynamic Binding ◽  
Legacy Software ◽  
Original Program

Object-oriented languages support many modern programming concepts such as information hiding, inheritance, polymorphism, and dynamic binding. As a result, software systems implemented in OO languages are in general more reusable and reliable than others. Many legacy software systems, created before OO programming became popular, need to be redesigned and updated to OO programs. The process of abstracting OO designs from the procedural source code has often been done with limited assistance from program structural diagrams. Most reengineering focuses on the functionality of the original program, and the OO redesign often results in a completely new design based on the designers' understanding of the original program. Such an approach is not sufficient because it may take a significant amount of time and effort for designers to comprehend the original program. This paper presents a computer-aided semi-automatic method that abstracts OO designs from the original procedural source code. More specifically, it is a method for OO redesign based on program structural diagrams, visualization, and execution slices. We conducted a case study by applying this method to an inventory management software system. Results indicate that our method can effectively and efficiently abstract an appropriate OO design out of the original C code. In addition, some of the code from the original system can be automatically identified and reused in the new OO system.

scholarly journals Towards a model-driven approach for multiexperience AI-based user interfaces

2021 ◽  
Author(s):  
Elena Planas ◽  
Gwendal Daniel ◽  
Marco Brambilla ◽  
Jordi Cabot
Keyword(s):  
User Interface ◽  
Language Processing ◽  
User Interfaces ◽  
The Other ◽  
Software Systems ◽  
Model Driven ◽  
Software Applications ◽  
Domain Specific ◽  
Faster Development ◽  
Model Driven Approach

AbstractSoftware systems start to include other types of interfaces beyond the “traditional” Graphical-User Interfaces (GUIs). In particular, Conversational User Interfaces (CUIs) such as chat and voice are becoming more and more popular. These new types of interfaces embed smart natural language processing components to understand user requests and respond to them. To provide an integrated user experience all the user interfaces in the system should be aware of each other and be able to collaborate. This is what is known as a multiexperience User Interface. Despite their many benefits, multiexperience UIs are challenging to build. So far CUIs are created as standalone components using a platform-dependent set of libraries and technologies. This raises significant integration, evolution and maintenance issues. This paper explores the application of model-driven techniques to the development of software applications embedding a multiexperience User Interface. We will discuss how raising the abstraction level at which these interfaces are defined enables a faster development and a better deployment and integration of each interface with the rest of the software system and the other interfaces with whom it may need to collaborate. In particular, we propose a new Domain Specific Language (DSL) for specifying several types of CUIs and show how this DSL can be part of an integrated modeling environment able to describe the interactions between the modeled CUIs and the other models of the system (including the models of the GUI). We will use the standard Interaction Flow Modeling Language (IFML) as an example “host” language.

scholarly journals A Model Driven Approach to Upgrade Package-Based Software Systems

2010 ◽  
pp. 262-276 ◽  
Author(s):  
Antonio Cicchetti ◽  
Davide Di Ruscio ◽  
Patrizio Pelliccione ◽  
Alfonso Pierantonio ◽  
Stefano Zacchiroli
Keyword(s):  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach
Sign in / Sign up

Export Citation Format

Share Document