3,188 research outputs found
Analysing Reverse Engineering Techniques for Interactive Systems
Reverse engineering is the process of discovering a model of a software system by analyzing its structure and functions. Reverse engineering techniques applied to interactive software applications (e.g. applications with user interfaces (UIs)) are very important and significant, as they can help engineers to detect defects in the software and then improve or complete them. There are several approaches, and many different tools, which are able to reverse-engineer software applications into formal models. These can be classified into two main types: dynamic tools and static tools. Dynamic tools interact with the application to find out the run-time behaviours of the software, simulating the actions of a user to explore the system’s state space, whereas static tools focus on static structure and architecture by analysing the code and documents. Reverse engineering techniques are not common for interactive software systems, but nowadays more and more organizations recognize the importance of interactive systems, as the trend in software used in computers is for applications with graphical user interfaces. This has in turn led to a developing interest in reverse engineering tools for such systems.
Many reverse engineering tools generate very big models which make analysis slow and resource intensive. The reason for this is the large amount of information that is generated by the existing reverse engineering techniques. Slicing is one possible technique which helps with reducing un-necessary information for building models of software systems. This project focuses on static analysis and slicing, and considers how they can aid reverse engineering techniques for interactive systems, particularly with respect to the generation of a particular set of models, Presentation Models (PModels) and Presentation Interaction Models (PIMs)
GUIsurfer : a reverse engineering framework for user interface software
GUIsurfer: A Reverse Engineering Framework for User Interface Softwar
System to Software Integrity: A Case Study
It is widely acknowledged that the main source of cost for developing high-integrity software systems is their verification. A significant portion of this verification cost is spent assessing that software complies with its requirements.
Over the years several different methods have been developed to address this issue, in particular: testing, peer reviews, formal verification and automatic code generation. It is more and more frequent that these verification strategies are mixed within the same system, so as to adopt the most appropriate one for each component. This increases the complexity of the integration phase because it has to cope with multiple formalisms, development and verification methods.
Our goal is to propose a pragmatic process to integrate components developed using different methods into a single system and demonstrate that properties already verified for each component in isolation are preserved in their composition. This process leverages AADL as a pivotal modeling language for system specification and relies on specific verifications between the latter and the components developed using heterogeneous modeling and programming languages, namely Simulink for computation intensive parts and Ada/SPARK 2014 for other components.
Our paper proceeds as follows. First we provide a high-level overview of our approach and enumerate the current methods for addressing the property preservation problem. Then we illustrate practically our approach using the Nose Gear Challenge problem, a simplified yet complete example of a high-integrity real-time system. We then conclude by comparing our approach to the state of the art
UML Assisted Visual Debugging for Distributed Systems
The DOD is developing a Joint Battlespace Infosphere, linking a large number of data sources and user applications. To assist in this process, debugging and analysis tools are required. Software debugging is an extremely difficult cognitive process requiring comprehension of the overall application behavior, along with detailed understanding of specific application components. This is further complicated with distributed systems by the addition of other programs, their large size and synchronization issues. Typical debuggers provide inadequate support for this process, focusing primarily on the details accessible through source code. To overcome this deficiency, this research links the dynamic program execution state to a Unified Modeling Language (UML) class diagram that is reverse-engineered from data accessed within the Java Platform Debug Architecture. This research uses focus + context, graph layout, and color encoding techniques to enhance the standard UML diagram. These techniques organize and present objects and events in a manner that facilitates analysis of system behavior. High-level abstractions commonly used in system design support debugging while maintaining access to low-level details with an interactive display. The user is also able to monitor the control flow through highlighting of the relevant object and method in the display
Ensuring behavioural equivalence in test-driven porting
In this paper we present a test-driven approach
to porting code from one object-oriented language
to another. We derive an order for
the porting of the code, along with a testing
strategy to verify the behaviour of the
ported system at intra and inter-class level.
We utilise the recently defined methodology
for porting C++ applications, eXtreme porting,
as a framework for porting. This defines
a systematic routine based upon porting
and unit-testing classes in turn. We augment
this approach by using Object Relation
Diagrams to define an order for porting that
minimises class stubbing. Since our strategy
is class-oriented and test-driven, we can ensure
the structural equivalence of the ported
system, along with the limited behavioural
equivalence of each class. In order to extend
this to integration-level equivalence, we exploit
aspect-oriented programming to generate UML
sequence diagrams, and we present a technique
to compare such automatically-generated diagrams
for equivalence. We demonstrate and
evaluate our approach using a case study that
involves porting an application from C++ to
Java
Ensuring behavioural equivalence in test-driven porting
In this paper we present a test-driven approach
to porting code from one object-oriented language
to another. We derive an order for
the porting of the code, along with a testing
strategy to verify the behaviour of the
ported system at intra and inter-class level.
We utilise the recently defined methodology
for porting C++ applications, eXtreme porting,
as a framework for porting. This defines
a systematic routine based upon porting
and unit-testing classes in turn. We augment
this approach by using Object Relation
Diagrams to define an order for porting that
minimises class stubbing. Since our strategy
is class-oriented and test-driven, we can ensure
the structural equivalence of the ported
system, along with the limited behavioural
equivalence of each class. In order to extend
this to integration-level equivalence, we exploit
aspect-oriented programming to generate UML
sequence diagrams, and we present a technique
to compare such automatically-generated diagrams
for equivalence. We demonstrate and
evaluate our approach using a case study that
involves porting an application from C++ to
Java
Improving Automated Software Testing while re-engineering legacy systems in the absence of documentation
Legacy software systems are essential assets that contain an organizations' valuable business logic. Because
of outdated technologies and methods used in these systems, they are challenging to maintain and expand.
Therefore, organizations need to decide whether to redevelop or re-engineer the legacy system. Although
in most cases, re-engineering is the safer and less expensive choice, it has risks such as failure to meet the
expected quality and delays due to testing blockades. These risks are even more severe when the legacy
system does not have adequate documentation. A comprehensive testing strategy, which includes automated
tests and reliable test cases, can substantially reduce the risks. To mitigate the hazards associated with
re-engineering, we have conducted three studies in this thesis to improve the testing process.
Our rst study introduces a new testing model for the re-engineering process and investigates test automation
solutions to detect defects in the early re-engineering stages. We implemented this model on the
Cold Region Hydrological Model (CRHM) application and discovered bugs that would not likely have been
found manually. Although this approach helped us discover great numbers of software defects, designing test
cases is very time-consuming due to the lack of documentation, especially for large systems. Therefore, in
our second study, we investigated an approach to generate test cases from user footprints automatically. To
do this, we extended an existing tool to collect user actions and legacy system reactions, including database
and le system changes. Then we analyzed the data based on the order of user actions and time of them
and generated human-readable test cases. Our evaluation shows that this approach can detect more bugs
than other existing tools. Moreover, the test cases generated using this approach contain detailed oracles
that make them suitable for both black-box and white-box testing. Many scienti c legacy systems such as
CRHM are data-driven; they take large amounts of data as input and produce massive data after applying
mathematical models. Applying test cases and nding bugs is more demanding when we are dealing with
large amounts of data. Hence in our third study, we created a comparative visualization tool (ComVis) to
compare a legacy system's output after each change. Visualization helps testers to nd data issues resulting
from newly introduced bugs. Twenty participants took part in a user study in which they were asked to nd
data issued using ComVis and embedded CRHM visualization tool. Our user study shows that ComVis can
nd 51% more data issues than embedded visualization tools in the legacy system can. Also, results from
the NASA-TLX assessment and thematic analysis of open-ended questions about each task show users prefer
to use ComVis over the built-in visualization tool. We believe our introduced approaches and developed
systems will signi cantly reduce the risks associated with the re-engineering process.
i
Recommended from our members
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
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
- …