Search

Good software design is characterized by low coupling between modules and high cohesion inside each module. This is obtained by encapsulating the details about the internal structure of data and exporting only public functions with a clean interface. For programming languages such as C, which offer little support for encapsulation, code analysis tools may help in assessing and improving the access to data structures. In this paper a new representation of the accesses of functions to dynamic locations, called the O-A diagram, is proposed. By isolating meaningful groups of functions working on common dynamic data, such a diagram can be used to evaluate the encapsulation in a program and to drive possible interventions to improve it. Experimental results suggest that the aggregations identified by the O-A diagram are actually cohesive functions operating on a shared data structure. The results are useful in themselves, by providing the programmer with information about the organization of the accesses to dynamic memory. In addition the O-A diagram permits highlighting violations of encapsulation, so that proper restructuring actions can be performed.

The dynamic evolution of ecological systems in which predators and prey compete for survival has been investigated by applying suitable mathematical models. This kind of mathematical framework has been shown to be suited to describe evolution of economical systems as well, where instead of predators and prey there are consumers and resources. We believe that this kind of system, called dynamic systems, could be usefully applied to informatics context, for example to model the dynamic interactions of client/server systems, such as Internet users and Web servers. We present the general mathematical model, often referred to in biological and economics literature, and show how to apply dynamic systems theory to model client/server interactions in different system load conditions. Web clients compete to obtain some URLs from the server and the efficiency of the server decreases when the number of clients increases, in a similar way to predator and prey populations. The feasibility of this approach is supported by experimental results.

The dynamic evolution of ecological systems in which predators and prey compete for survival has been investigated by applying suitable mathematical models. Dynamic systems theory provides a useful way to model interspecies competition and thus the evolution of predators and prey populations. This kind of mathematical framework has been shown to be well suited to describe evolution of economical systems as well, where instead of predators and prey there are consumers and resources. This paper suggests how dynamic systems could be usefully applied to the maintenance context, namely to model the dynamic evolution of the maintenance effort. When maintainers start trying to recognize and correct code defects, while the number of residual defects decreases, the effort spent to find out any new defect has an initial increase, followed by a decline, in a similar way to prey and predator populations. The feasibility of this approach is supported by the experimental data about a 67 months maintenance task of a software project and its successive releases.

During maintenance activities, the availability of integrated conceptual views that present software at different levels of abstraction, from software architecture to control and data flow relations at code level, is fundamental to understand and modify legacy systems. This paper presents CANTO (Code and Architecture Analysis Tool), a comprehensive program understanding and maintenance environment which integrates fine grained information with architectural views extracted from source code, giving the user control of what is being computed by analyses. The capabilities and usefulness of CANTO are illustrated with reference to a real understanding and maintenance task

An approach to reengineer BASIC PC legacy code into modern graphical systems is proposed. BASIC has historically been one of the first languages available on PCs. Based on it, small or medium size companies have developed systems that represent valuable company assets to be preserved. Our goal is the automatic migration from the BASIC character oriented user interface to a graphical environment which includes a GUI builder, and compiles event driven C/C++ code. For this purpose a conceptual representation in terms of abstract graphical objects and call-backs has been inferred from the original code, and a translator from BASIC to C has been developed. Moreover the GUI builder internal representation has been generated, so that the user interface can be interactively fine-tuned by the programmer. We present and discuss BASIC peculiarities, with preliminary results on code translation. For the explanation of our approach to user interface migration an example is used throughout the text.

During the evolution phase, the structure (pages and links) of a Web application tends unavoidably to degrade. A solution to reverse this degradation can be restructuring the Web application, but this work may take a lot of time and effort if conducted without appropriate tools. The theory of rewrite rules has been used with success in many real restructuring works on traditional software. Our idea is trying to apply rewrite rules to Web applications with the aim of restructuring them. The purpose of the paper is threefold: to describe our initial ideas on HTML rewrites to improve the quality of Web applications, to present our approach for implementing a tool, based on transformation rules, that can help designers in Web application restructuring and to define the starting point of the joint project between ITC-irst and Semantic Designs.

UML diagrams, and in particular the most frequently used one, the class diagram, represent a valuable source of information even after the delivery of the system, when it enters the maintenance phase. Several tools provide a reverse engineering engine to recover it from the code. In this paper an algorithm is proposed for the improvement of the accuracy of the UML class diagram extracted from the code. Specifically, important information about inter-class relations may be missed in a reverse engineered class diagram, when weakly typed containers, i.e., containers collecting objects whose type is the top of the inheritance hierarchy, are employed. In fact, the class of the contained objects is not directly known, and therefore no relation with it is apparent from the container declaration. The proposed approach was applied to several software components developed at CERN. Experimental results highlight that a substantial improvement is achieved when the container type information is refined with the inferred data. The number of relations otherwise missed is relevant and the connectivity of the associated class diagrams is radically different when containers are considered.

Current practice of Web site development does not address explicitly the problems related to multilingual sites. The same information, as well as the same navigation paths, page formatting and organization, are expected to be provided by the site independently from the chosen language. This is typically ensured by adopting personal conventions on the way pages are named and on their location in the file system. Updates are then performed manually and consistency depends on the ability of the programmers not to miss any impact of the change. In this paper an extension to XHTML, called MLHTML (MultiLingual XHTML), is proposed as the target representation of a restructuring process aimed at producing a maintainable and consistent multilingual Web site. MLHTML centralizes the language dependent variants of a page in a single representation, where shared parts are not duplicated Existing sites can be migrated to MLHTML by means of the algorithms described in this paper. After classifying the pages according to their language, a page alignment technique is exploited to identify corresponding pages and to eliminate inconsistencies. Transformation into MLHTML can then be achieved automatically.

The World Wide Web has become an interesting opportunity for companies to deliver services and products at distance. Correspondingly, the quality of Web applications, responsible for the related transactions, has become a crucial factor. It can be improved by properly modeling the application during its design, but if the whole life cycle is considered, the availability of a consistent model of the application is fundamental also during maintenance and testing. In this chapter, the problem of recovering a model of a Web application from the implementation is faced. Algorithms are provided to obtain it even in presence of a highly dynamic structure. Based upon such a model, several static analysis techniques, among which reaching definitions and slicing, are considered, as well as some restructuring techniques. White box testing exploits the model in that the related coverage levels are based on it, while statistical testing assumes that transitions in the model are labeled with the conditional probabilities of being traversed.

During the evolution phase, the structure (pages and links) of a Web application tends unavoidably to degrade. A solution to reverse this degradation can be restructuring the Web application, but this work may take a lot of time and effort if conducted without appropriate tools. The theory of rewrite rules has been used with success in many real restructuring works on traditional software. Our idea is trying to apply rewrite rules to Web applications with the aim of restructuring them. The purpose of this paper is threefold: to describe some examples of HTML transforms improving the quality of Web applications, to present some details about the implementation of a tool, based on rewrite rules, that can help designers in Web application restructuring, and to describe the results obtained on some real world applications.

Program slicing revealed a useful way to limit the search of software defects during debugging and to better understand the decomposition of the application into computations. We propose to extend the extraction of slices to Web applications, in order to produce a reduced Web application which behaves as the original one with respect to some criterion, i.e., some displayed information of interest. After presenting the theoretical implications of applying slicing to Web applications, we demonstrate its usefulness with reference to an example, derived from a survey of a set of travel agency sites. Web application slicing helps to disclose relevant information and understand the internal system structure.

The problem of verifying the consistency between Web site portions devoted to different languages is investigated. The purpose is to support the activity of the site maintainer, who is responsible for the alignment between different site versions. Anomalies that typically occur in such situations include the absence of pages in some languages, differences in the page structure in different languages, missing information and parts not translated. The approach which is proposed for recovering traceability links so as to simplify the update of the site to a consistent state, is based on a mix of structural and textual information extracted from the page. The syntax trees of the pages to be compared drive the page matching process. When structurally corresponding nodes are encountered during the tree visit, their text attributes are considered to see if they are each other's translation.

Web applications are becoming increasingly complex and important for companies. Their design, development, analysis and testing need therefore to be approached by means of support tools and methodologies. In this paper we consider the problems related to building tools for the analysis and testing of Web applications and we try to provide some indications on possible solutions, based upon our experience in the development of the tools ReWeb and Test Web.The definition of a proper reference model will be discussed, as well as the impact of dynamic pages during Web site downloading and subsequent model construction. Visualization techniques addressing the large amount of extracted data will be presented, while infeasibility problems will be considered with reference to the testing phase.

When designing a new application, experienced software engineers usually try to employ solutions that proved successful in previous projects. Such reuse of code organizations is seldom made explicit. Nevertheless it represents important information about the system, that can be extremely valuable in the maintenance phase by documenting the design choices underlying the implementation. In addition, having it available, it can be reused whenever a similar problem is encountered. In this paper an approach is proposed to the inference of recurrent design patterns directly from the code or the design. No assumption is made on the availability of any pattern library and the concept analysis algorithm, adapted for this purpose, is able to infer the presence of class groups which instantiate a common, repeated pattern. In fact, concept analysis provides sets of objects sharing attributes, which, in the case of object oriented design patterns, become class members or inter-class relations. The approach was applied to a C++ application, for which the structural relations among classes led to the extraction of a set of structural design patterns, which could be enriched with non structural information about class members and method invocations. The resulting patterns could be interpreted as meaningful organizations aimed at solving general problems which have several instances in the analyzed application.

A novel application of the Reactive Tabu Search to Vector Quantization (RTS-VQ) is presented. The results obtained on benchmark tasks demonstrate that a performance similar to that of traditional techniques can be obtained even if the code vectors are represented with small integers. The result is of interest for application-specific VLSI circuits.

One of the most complex tasks for business analysts is the consistent management of crosscutting concerns in large business processes. By crosscutting concerns the authors mean those process features that are not assigned to a single modular unit in the process and are thus scattered and tangled with other features. For example, the adaptation of the process to the user preferences involves several scattered activities that constitute a crosscutting concern. In this study, the authors propose a semi-automatic approach, based on formal concept analysis, for the identification of crosscutting concerns in business processes at design time. A preliminary evaluation of the effectiveness of the proposed technique in detecting crosscutting concerns has been provided by applying the approach to a case study.

As Multi-Agent Systems (MASs) are increasingly applied in complex distributed applications such as financial and healthcare services, assurance needs to be given to the user that the implemented MASs operate properly, i.e., they meet their specifications and the stakeholder's expectations. Testing is an important and widely applied technique in practice to reach this goal. Current Agent-Oriented Software Engineering (AOSE) methodologies address testing only partially. Some of them exploit Object-Oriented (OO) testing techniques, based on a mapping of agent-oriented abstractions into OO constructs; this may require additional development effort and introduce anomalies. Moreover, a structured testing process for AOSE methodologies is still missing. In this paper we introduce a testing methodology, called Goal-Oriented Software Testing (GOST), for MAS. The methodology specifies a testing process that complements goal-oriented analysis and design. Furthermore, GOST provides a systematic way of deriving test cases from goal-oriented specifications and techniques to automate test case generation and their execution.

The C++ programming language offers a wide range of coding alternatives to programmers. Some language characteristics inherited from C are potential sources of problems during the evolution of a system. Global variables, arbitrary branches, pointers, memory management instructions and macro directives are examples of them. The resulting code may be difficult to understand, maintain and test, if such language features are used without proper discipline. The Java language was designed with the explicit goal of excluding all troublesome features that can be found in C++, by disregarding some of them (e.g., globals), and disciplining other ones (e.g., pointers). For several companies the migration to Java is not strategically feasible. Nevertheless, the adoption of its philosophy within C++ code could help improve the quality of the software. In this paper a subset of C++, named Cjj, is defined which is compliant with Java, in that it enforces a Java-like programming style, while forbidding all C++ constructs that are in contrast with it. A tool for the verification of the compliance of an input source with Cjj was developed. It verifies if any of the constraints defining Cjj is violated.

The identifiers chosen by programmers as function names contain valuable information. They are often the starting point for program understanding activities, especially when high-level views, like the call graph, are available. In this paper, the lexical, syntactic and semantic structure of function identifiers is analyzed by means of a segmentation technique, a regular language and a conceptual classification. The application of these analyses to a database of procedural programs suggests some potential uses of the results, ranging from support for program understanding to the evolution towards standard and more maintainable forms of programs.

A system built in terms of autonomous software agents may require even greater correctness assurance than one that is merely reacting to the immediate control of its users. Agents make substantial decisions for themselves, so thorough testing is an important consideration. However, autonomy also makes testing harder; by their nature, autonomous agents may react in different ways to the same inputs over time, because, for instance they have changeable goals and knowledge. For this reason, we argue that testing of autonomous agents requires a procedure that caters for a wide range of test case contexts, and that can search for the most demanding of these test cases, even when they are not apparent to the agents' developers. In this paper, we address this problem, introducing and evaluating an approach to testing autonomous agents that uses evolutionary optimisation to generate demanding test cases. We propose a methodology to derive objective (fitness) functions that drive evolutionary algorithms, and evaluate the overall approach with two simulated autonomous agents. The obtained results show that our approach is effective in finding good test cases automatically.

The state space of Android apps is huge, and its thorough exploration during testing remains a significant challenge. The best exploration strategy is highly dependent on the features of the app under test. Reinforcement Learning (RL) is a machine learning technique that learns the optimal strategy to solve a task by trial and error, guided by positive or negative reward, rather than explicit supervision. Deep RL is a recent extension of RL that takes advantage of the learning capabilities of neural networks. Such capabilities make Deep RL suitable for complex exploration spaces such as one of Android apps. However, state-of-the-art, publicly available tools only support basic, Tabular RL. We have developed ARES, a Deep RL approach for black-box testing of Android apps. Experimental results show that it achieves higher coverage and fault revelation than the baselines, including state-of-the-art tools, such as TimeMachine and Q-Testing. We also investigated the reasons behind such performance qualitatively, and we have identified the key features of Android apps that make Deep RL particularly effective on them to be the presence of chained and blocking activities. Moreover, we have developed FATE to fine-tune the hyperparameters of Deep RL algorithms on simulated apps, since it is computationally expensive to carry it out on real apps.

Enriching business process models with semantic annotations taken from an ontology has become a crucial necessity both in service provisioning, integration and composition, and in business processes management. In our work we represent semantically annotated business processes as part of an OWL knowledge base that formalises the business process structure, the business domain, and a set of criteria describing correct semantic annotations. In this paper we show how Semantic Web representation and reasoning techniques can be effectively applied to formalise, and automatically verify, sets of constraints on Business Process Diagrams that involve both knowledge about the domain and the process structure. We also present a tool for the automated transformation of an annotated Business Process Diagram into an OWL ontology. The use of the semantic web techniques and tool presented in the paper results in a novel support for the management of business processes in the phase of process modeling, whose feasibility and usefulness will be illustrated by means of a concrete example.

Uncertainty and confidence have been shown to be useful metrics in a wide variety of techniques proposed for deep learning testing, including test data selection and system supervision. We present uncertainty-wizard, a tool that allows to quantify such uncertainty and confidence in artificial neural networks. It is built on top of the industry-leading tf.keras deep learning API and it provides a near-transparent and easy-to-understand interface. At the same time, it includes major performance optimizations that we benchmarked on two different machines and different configurations., Backup Recording for the Talk @ ICST 2021

The outcome of test case execution depends on the state of the object under test. While testers can carefully choose meaningful and representative object states for test execution, it is unaffordable to cover the combinatorial space of possible object states exhaustively. An appealing option is to delegate part of the testing activities to the runtime and to execute test cases in the field whenever a new or uncommon state is observed. We have designed and developed Groucho, a framework for in-vivo testing of Java applications. Among the challenges that we faced, the most important ones are isolation of the test session from the user session and minimal performance overhead. Experimental results show that if the activation probability is kept reasonably small (e.g., $10 ^{- {4}}$), the impact of the framework is imperceptible(i.e., either statistically insignificant or with a negligible effect size).

The starting point for software evolution is usually a change request, expressing the new or updated requirements on the delivered system. The requirements specified in a change request document are often incomplete and inconsistent with the initial requirement document, as well as the implementation. Programmers working on the evolution of the software are often in trouble interpreting an under-specified change request document, resulting in code that does not meet the users' expectations and contains faults that can only be detected later through expensive testing activities.In this paper, we investigate the role of acceptance tests to clarify the requirements used in software evolution iterations. In particular we focus on Fit tables, a way to express acceptance tests which simplifies their translation into executable test cases. We designed and ran an experiment to assess whether availability of Fit tables affects the level of understanding and the productivity in understanding the requirements. Results indicate that Fit tables significantly improve requirement understanding, but tend to involve additional effort.

The fact that crosscutting concerns (aspects) cannot be well modularized in object oriented software is an impediment to program comprehension: the implementation of a concern is typically scattered over many locations and tangled with the implementation of other concerns, resulting in a system that is hard to explore and understand. Aspect mining aims to identify crosscutting concerns in a system, thereby improving the system's comprehensibility and enabling migration of existing (object-oriented) programs to aspect-oriented ones. In this paper, we compare three aspect mining techniques that were developed independently by different research teams: fan-in analysis, identifier analysis and dynamic analysis. We apply each technique to the same case (JHotDraw) and mutually compare the individual results of each technique based on the discovered aspects and on the level of detail and quality of those aspects. Strengths, weaknesses and underlying assumptions of each technique are discussed, as well as their complementarity. We conclude with a discussion of possible ways to combine the techniques in order to achieve a better overall aspect-mining technique.

Mobile apps can be executed with an extremely large set of partially unpredictable configurations.Indeed, they can be executed on an unbounded combination of devices, operating systems, settings, and user preferences since apps may also interact with other apps or devices that were not even available when they were released.This results in a virtually infinite set of configurations that might be responsible for unexpected behaviors which can be validated in-house only to a negligible extent. To address this challenge, this paper discusses the application of in-vivo testing to mobile apps. The main idea is to run test cases in the field, where we exploit the intrinsic heterogeneity and variety of the end-user environment to dramatically increase the range of validated configurations. Actually, the many devices available in-the-field generate a naturally distributed and highly scalable environment that can be exploited to timely validate many configurations as soon as they are observed.&nbsp