9 research outputs found
Combining formal methods and functional strategies regarding the reverse engineering of interactive applications
Graphical user interfaces (GUIs) make software easy to use by providing the user with visual controls. Therefore, correctness of GUI’s code is essential to the correct execution of the overall software. Models can help in the evaluation of interactive applications by allowing designers to concentrate on its more important aspects. This paper describes our approach to reverse engineer an abstract model of a user interface directly from the GUI’s legacy code. We also present results from a case study. These results are encouraging and give evidence that the goal of reverse engineering user interfaces can be met with more work on this technique.Fundação para a Ciência e a Tecnologia (FCT)
Fundo Europeu de Desenvolvimento Regional (FEDER
The GUISurfer tool: towards a language independent approach to reverse engineering GUI code
Graphical user interfaces (GUIs) are critical components of today's software. Developers are dedicating a larger portion of code to implementing them. Given their increased importance, correctness of GUIs code is becoming essential. This paper describes the latest results in the development of GUISurfer, a tool to reverse engineer the GUI layer of interactive computing systems. The ultimate goal of the tool is to enable analysis of interactive system from source code
Interaction engineering using the IVY tool
This paper is concerned with support for the process of usability engineering. The aim is to use formal techniques to provide a systematic approach that is more traceable, and because it is systematic, repeatable. As a result of this systematic process some of the more subjective aspects of the analysis can be removed. The technique explores exhaustively those features of a specific design that fail to satisfy a set of properties. It also analyzes those aspects of the design where it is possible to quantify the cost of use. The method is illustrated using the example of a medical device. While many aspects of the approach and its tool support have already been discussed elsewhere, this paper builds on and contrasts an analysis of the same device provided by a third party and in so doing enhances the IVY tool
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)
Combining Formal Methods and Functional Strategies Regarding the Reverse Engineering of Interactive Applications
Abstract. Graphical user interfaces (GUIs) make software easy to use
by providing the user with visual controls. Therefore, correctness of
GUI’s code is essential to the correct execution of the overall software.
Models can help in the evaluation of interactive applications by allowing
designers to concentrate on its more important aspects. This paper
describes our approach to reverse engineer an abstract model of a user
interface directly from the GUI’s legacy code. We also present results
from a case study. These results are encouraging and give evidence that
the goal of reverse engineering user interfaces can be met with more work
on this technique
Investigating Strategies to Support Reverse-Engineering of Interactive Systems
Most software applications today provide a graphical user interface (GUI), which facilitates the use of the software by offering graphical and visual elements to the users. The correctness of the user interface is fundamental to the correct implementation of the overall software. Using reverse engineering tools and methods is one of the most efficient ways to understand a system, and to assess its functionality and usability. However, traditional reverse engineering methods are not well suited to interactive elements of a system. This research examines and analyzes reverse engineering techniques of interactive systems written in the Java programming language, with the aim of creating a set of models of the entire system namely, Presentation Models (PModels) and Presentation Interaction Models (PIMs), which are very effective in describing structural and functional behavioral features of the interactive system. This study will also highlight some of the problems that exist in this domain and investigate several possibilities for improving the process
Customizable Feature based Design Pattern Recognition Integrating Multiple Techniques
Die Analyse und Rückgewinnung von Architekturinformationen
aus existierenden Altsystemen ist eine komplexe, teure und zeitraubende
Aufgabe, was der kontinuierlich steigenden Komplexität von Software und dem
Aufkommen der modernen Technologien geschuldet ist. Die Wartung von
Altsystemen wird immer stärker nachgefragt und muss dabei mit den neuesten
Technologien und neuen Kundenanforderungen umgehen können. Die
Wiederverwendung der Artefakte aus Altsystemen für neue Entwicklungen wird
sehr bedeutsam und überlebenswichtig für die Softwarebranche. Die
Architekturen von Altsystemen unterliegen konstanten Veränderungen, deren
Projektdokumentation oft unvollständig, inkonsistent und veraltet ist.
Diese Dokumente enthalten ungenügend Informationen über die innere Struktur
der Systeme. Häufig liefert nur der Quellcode zuverlässige Informationen
über die Struktur von Altsystemen. Das Extrahieren von Artefakten aus
Quellcode von Altsystemen unterstützt das Programmverständnis, die Wartung,
das Refactoring, das Reverse Engineering, die nachträgliche Dokumentation
und Reengineering Methoden. Das Ziel dieser Dissertation ist es
Entwurfsinformationen von Altsystemen zu extrahieren, mit Fokus auf die
Wiedergewinnung von Architekturmustern. Architekturmuster sind
Schlüsselelemente, um Architekturentscheidungen aus Quellcode von
Altsystemen zu extrahieren. Die Verwendung von Mustern bei der Entwicklung
von Applikationen wird allgemein als qualitätssteigernd betrachtet und
reduziert Entwicklungszeit und kosten. In der Vergangenheit wurden
unterschiedliche Methoden entwickelt, um Muster in Altsystemen zu erkennen.
Diese Techniken erkennen Muster mit unterschiedlicher Genauigkeit, da ein
und dasselbe Muster unterschiedlich spezifiziert und implementiert wird.
Der Lösungsansatz dieser Dissertation basiert auf anpassbaren und
wiederverwendbaren Merkmal-Typen, die statische und dynamische Parameter
nutzen, um variable Muster zu definieren. Jeder Merkmal-Typ verwendet eine
wählbare Suchtechnik (SQL Anfragen, Reguläre Ausdrücke oder Quellcode
Parser), um ein bestimmtes Merkmal eines Musters im Quellcode zu
identifizieren. Insbesondere zur Erkennung verschiedener Varianten eines
Musters kommen im entwickelten Verfahren statische, dynamische und
semantische Analysen zum Einsatz. Die Verwendung unterschiedlicher
Suchtechniken erhöht die Genauigkeit der Mustererkennung bei verschiedenen
Softwaresystemen. Zusätzlich wurde eine neue Semantik für Annotationen im
Quellcode von existierenden Softwaresystemen entwickelt, welche die
Effizienz der Mustererkennung steigert. Eine prototypische
Implementierung des Ansatzes, genannt UDDPRT, wurde zur Erkennung
verschiedener Muster in Softwaresystemenen unterschiedlicher
Programmiersprachen (JAVA, C/C++, C#) verwendet. UDDPRT erlaubt die
Anpassung der Mustererkennung durch den Benutzer. Alle Abfragen und deren
Zusammenspiel sind konfigurierbar und erlauben dadurch die Erkennung von
neuen und abgewandelten Mustern. Es wurden umfangreiche Experimente mit
diversen Open Source Software Systemen durchgeführt und die erzielten
Ergebnisse wurden mit denen anderer Ansätze verglichen. Dabei war es
möglich eine deutliche Steigerung der Genauigkeit im entwickelten Verfahren
gegenüber existierenden Ansätzen zu zeigen.Recovering design information from legacy applications is a
complex, expensive, quiet challenging, and time consuming task due to ever
increasing complexity of software and advent of modern technology. The
growing demand for maintenance of legacy systems, which can cope with the
latest technologies and new business requirements, the reuse of artifacts
from the existing legacy applications for new developments become very
important and vital for software industry. Due to constant evolution in
architecture of legacy systems, they often have incomplete, inconsistent
and obsolete documents which do not provide enough information about the
structure of these systems. Mostly, source code is the only reliable source
of information for recovering artifacts from legacy systems. Extraction of
design artifacts from the source code of existing legacy systems supports
program comprehension, maintenance, code refactoring, reverse engineering,
redocumentation and reengineering methodologies. The objective of approach
used in this thesis is to recover design information from legacy code with
particular focus on the recovery of design patterns. Design patterns are
key artifacts for recovering design decisions from the legacy source code.
Patterns have been extensively tested in different applications and reusing
them yield quality software with reduced cost and time frame. Different
techniques, methodologies and tools are used to recover patterns from
legacy applications in the past. Each technique recovers patterns with
different precision and recall rates due to different specifications and
implementations of same pattern. The approach used in this thesis is based
on customizable and reusable feature types which use static and dynamic
parameters to define variant pattern definitions. Each feature type allows
user to switch/select between multiple searching techniques (SQL queries,
Regular Expressions and Source Code Parsers) which are used to match
features of patterns with source code artifacts. The technique focuses on
detecting variants of different design patterns by using static, dynamic
and semantic analysis techniques. The integrated use of SQL queries, source
code parsers, regular expressions and annotations improve the precision and
recall for pattern extraction from different legacy systems. The approach
has introduced new semantics of annotations to be used in the source code
of legacy applications, which reduce search space and time for detecting
patterns. The prototypical implementation of approach, called UDDPRT is
used to recognize different design patterns from the source code of
multiple languages (Java, C/C++, C#). The prototype is flexible and
customizable that novice user can change the SQL queries and regular
expressions for detecting implementation variants of design patterns. The
approach has improved significant precision and recall of pattern
extraction by performing experiments on number of open source systems taken
as baselines for comparisons
Structural usability techniques for dependable HCI.
Since their invention in the middle of the twentieth century, interactive computerised systems have become more and more common to the point of ubiquity. While formal techniques have developed as tools for understanding and proving things about the behaviour of computerised systems, those that involve interaction with human users present some particular challenges which are less well addressed by traditional formal methods. There is an under-explored space where interaction and the high assurances provided by formal approaches meet. This thesis presents two techniques which fit into this space, and which can be used to automatically build and analyse formal models of the interaction behaviour of existing systems. Model discovery is a technique for building a state space-based formal model of the interaction behaviour of a running system. The approach systematically and exhaustively simulates the actions of a user of the system; this is a dynamic analysis technique which requires tight integration with the running system and (in practice) its codebase but which, when set up, can proceed entirely automatically. Theorem discovery is a technique for analysing a state space-based formal model of the interaction behaviour of a system, looking for strings of user actions that have equivalent effects across all states of the system. The approach systematically computes and compares the effects of ever-longer strings of actions, though insights can also arise from strings that are almost equivalent, and also from considering the meaning of sets of such equivalences. The thesis introduces and exemplifies each technique, considers how they may be used together, and demonstrates their utility and novelty, with case studies