189,552 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)
Software (re)modularization: Fight against the structure erosion and migration preparation
Software systems, and in particular, Object-Oriented sys- tems are models of the real world that manipulate representa- tions of its entities through models of its processes. The real world is not static: new laws are created, concurrents offer new functionalities, users have renewed expectation toward what a computer should offer them, memory constraints are added, etc. As a result, software systems must be continuously updated or face the risk of becoming gradually out-dated and irrelevant [34]. In the meantime, details and multiple abstraction levels result in a high level of com- plexity, and completely analyzing real software systems is impractical. For example, the Windows operating system consists of more than 60 millions lines of code (500,000 pages printed double-face, about 16 times the Encyclopedia Universalis). Maintaining such large applications is a trade- off between having to change a model that nobody can understand in details and limiting the impact of possible changes. Beyond maintenance, a good structure gives to the software systems good qualities for migration towards modern paradigms as web services or components, and the problem of architecture extraction is very close to the classical remodularization problem
Lightweight Multilingual Software Analysis
Developer preferences, language capabilities and the persistence of older
languages contribute to the trend that large software codebases are often
multilingual, that is, written in more than one computer language. While
developers can leverage monolingual software development tools to build
software components, companies are faced with the problem of managing the
resultant large, multilingual codebases to address issues with security,
efficiency, and quality metrics. The key challenge is to address the opaque
nature of the language interoperability interface: one language calling
procedures in a second (which may call a third, or even back to the first),
resulting in a potentially tangled, inefficient and insecure codebase. An
architecture is proposed for lightweight static analysis of large multilingual
codebases: the MLSA architecture. Its modular and table-oriented structure
addresses the open-ended nature of multiple languages and language
interoperability APIs. We focus here as an application on the construction of
call-graphs that capture both inter-language and intra-language calls. The
algorithms for extracting multilingual call-graphs from codebases are
presented, and several examples of multilingual software engineering analysis
are discussed. The state of the implementation and testing of MLSA is
presented, and the implications for future work are discussed.Comment: 15 page
Recommended from our members
Graph models for reachability analysis of concurrent programs
Reachability analysis is an attractive technique for analysis of concurrent programs because it is simple and relatively straightforward to automate, and can be used in conjunction with model-checking procedures to check for application-specific as well as general properties. Several techniques have been proposed differing mainly on the model used; some of these propose the use of flowgraph based models, some others of Petri nets.This paper addresses the question: What essential difference does it make, if any, what sort of finite-state model we extract from program texts for purposes of reachability analysis? How do they differ in expressive power, decision power, or accuracy? Since each is intended to model synchronization structure while abstracting away other features, one would expect them to be roughly equivalent.We confirm that there is no essential semantic difference between the most well known models proposed in the literature by providing algorithms for translation among these models. This implies that the choice of model rests on other factors, including convenience and efficiency.Since combinatorial explosion is the primary impediment to application of reachability analysis, a particular concern in choosing a model is facilitating divide-and-conquer analysis of large programs. Recently, much interest in finite-state verification systems has centered on algebraic theories of concurrency. Yeh and Young have exploited algebraic structure to decompose reachability analysis based on a flowgraph model. The semantic equivalence of graph and Petri net based models suggests that one ought to be able to apply a similar strategy for decomposing Petri nets. We show this is indeed possible through application of category theory
ADAM: Analysis of Discrete Models of Biological Systems Using Computer Algebra
Background: Many biological systems are modeled qualitatively with discrete
models, such as probabilistic Boolean networks, logical models, Petri nets, and
agent-based models, with the goal to gain a better understanding of the system.
The computational complexity to analyze the complete dynamics of these models
grows exponentially in the number of variables, which impedes working with
complex models. Although there exist sophisticated algorithms to determine the
dynamics of discrete models, their implementations usually require
labor-intensive formatting of the model formulation, and they are oftentimes
not accessible to users without programming skills. Efficient analysis methods
are needed that are accessible to modelers and easy to use. Method: By
converting discrete models into algebraic models, tools from computational
algebra can be used to analyze their dynamics. Specifically, we propose a
method to identify attractors of a discrete model that is equivalent to solving
a system of polynomial equations, a long-studied problem in computer algebra.
Results: A method for efficiently identifying attractors, and the web-based
tool Analysis of Dynamic Algebraic Models (ADAM), which provides this and other
analysis methods for discrete models. ADAM converts several discrete model
types automatically into polynomial dynamical systems and analyzes their
dynamics using tools from computer algebra. Based on extensive experimentation
with both discrete models arising in systems biology and randomly generated
networks, we found that the algebraic algorithms presented in this manuscript
are fast for systems with the structure maintained by most biological systems,
namely sparseness, i.e., while the number of nodes in a biological network may
be quite large, each node is affected only by a small number of other nodes,
and robustness, i.e., small number of attractors
Analysis of Software Binaries for Reengineering-Driven Product Line Architecture\^aAn Industrial Case Study
This paper describes a method for the recovering of software architectures
from a set of similar (but unrelated) software products in binary form. One
intention is to drive refactoring into software product lines and combine
architecture recovery with run time binary analysis and existing clustering
methods. Using our runtime binary analysis, we create graphs that capture the
dependencies between different software parts. These are clustered into smaller
component graphs, that group software parts with high interactions into larger
entities. The component graphs serve as a basis for further software product
line work. In this paper, we concentrate on the analysis part of the method and
the graph clustering. We apply the graph clustering method to a real
application in the context of automation / robot configuration software tools.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301
PerfVis: Pervasive Visualization in Immersive AugmentedReality for Performance Awareness
Developers are usually unaware of the impact of code changes to the
performance of software systems. Although developers can analyze the
performance of a system by executing, for instance, a performance test to
compare the performance of two consecutive versions of the system, changing
from a programming task to a testing task would disrupt the development flow.
In this paper, we propose the use of a city visualization that dynamically
provides developers with a pervasive view of the continuous performance of a
system. We use an immersive augmented reality device (Microsoft HoloLens) to
display our visualization and extend the integrated development environment on
a computer screen to use the physical space. We report on technical details of
the design and implementation of our visualization tool, and discuss early
feedback that we collected of its usability. Our investigation explores a new
visual metaphor to support the exploration and analysis of possibly very large
and multidimensional performance data. Our initial result indicates that the
city metaphor can be adequate to analyze dynamic performance data on a large
and non-trivial software system.Comment: ICPE'19 vision, 4 pages, 2 figure, conferenc
- …