Search

One of the major challenges in the verification of complex industrial Cyber-Physical Systems is the difficulty of determining whether a particular system output or behaviour is correct or not, the so-called test oracle problem. Metamorphic testing alleviates the oracle problem by reasoning on the relations that are expected to hold among multiple executions of the system under test, which are known as Metamorphic Relations (MRs). However, the development of effective MRs is often challenging and requires the involvement of domain experts. In this paper, we present a case study aiming at automating this process. To this end, we implemented GAssertMRs, a tool to automatically generate MRs with genetic programming. We assess the cost-effectiveness of this tool in the context of an industrial case study from the elevation domain. Our experimental results show that in most cases GAssertMRs outperforms the other baselines, including manually generated MRs developed with the help of domain experts. We then describe the lessons learned from our experiments and we outline the future work for the adoption of this technique by industrial practitioners.

Modern web applications are characterized by ultra-rapid development cycles, and web testers tend to pay scant attention to the quality of their automated end-to-end test suites. Indeed, these quickly become hard to maintain, as the application under test evolves. As a result, end-to-end automated test suites are abandoned, despite their great potential for catching regressions. The use of the Page Object pattern has proven to be very effective in end-to-end web testing. Page objects are facade classes abstracting the internals of web pages into high-level business functions that can be invoked by the test cases. By decoupling test code from web page details, web test cases are more readable and maintainable. However, the manual development of such page objects requires substantial coding effort, which is paid off only later, during software evolution. In this paper, we describe a novel approach for the automatic generation of page objects for web applications. Our approach is implemented in the tool Apogen, which automatically derives a testing model by reverse engineering the target web application. It combines clustering and static analysis to identify meaningful page abstractions that are automatically turned into Java page objects for Selenium WebDriver. Our evaluation on an open-source web application shows that our approach is highly promising: Automatically generated page object methods cover most of the application functionalities and result in readable and meaningful code, which can be very useful to support the creation of more maintainable web test suites.

The importance of test automation in web engineering comes from the widespread use of web applications and the associated demand for code quality. Test automation is considered crucial for delivering the quality levels expected by users, since it can save a lot of time in testing and it helps developers to release web applications with fewer defects. The main advantage of test automation comes from fast, unattended execution of a set of tests after some changes have been made to a web application. Moreover, modern web applications adopt a multitier architecture where the implementation is scattered across different layers and run on different machines. For this reason, end-to-end testing techniques are required to test the overall behavior of web applications. In the last years, several approaches have been proposed for automated end-to-end web testing and the choice among them depends on a number of factors, including the tools used for web testing and the costs associated with their adoption. They can be classified using two main criteria: the first concerns how test cases are developed (ie, Capture-Replay and Programmable approaches), while, the second concerns how test cases localize the web elements to interact with (ie, Coordinates-based, DOM-based, and Visual approaches), that is what kind of locators are used for selecting the target GUI components. For developers and project managers it is not easy to select the most suitable automated end-to-end web testing approach for their needs among the existing ones. This chapter provides a comprehensive overview of the automated end-to-end web testing approaches and summarizes the findings of a long term research project aimed at empirically investigating their strengths and weaknesses.

Page objects are used in web test automation to decouple the test cases logic from their concrete implementation. Despite the undeniable advantages they bring, as decreasing the maintenance effort of a test suite, yet the burden of their manual development limits their wide adoption. In this demo paper, we give an overview of Apogen, a tool that leverages reverse engineering, clustering and static analysis, to automatically generate Java page objects for web applications.

Web applications are exposed to frequent changes both in requirements and involved technologies. At the same time, there is a continuously growing demand for quality and trust and such a fast evolution and quality constraints claim for mechanisms and techniques for automated testing. Web application automated testing often involves random crawlers to navigate the application under test and automatically explore its structure. However, owing to the specific challenges of the modern Web systems, automatic crawlers may leave large portions of the application unexplored. In this paper, we propose the use of structural metrics to predict whether an automatic crawler with given crawling capabilities will be sufficient or not to achieve high coverage of the application under test. In this work, we define a taxonomy of such capabilities and we determine which combination of them is expected to give the highest reward in terms of coverage increase. Our proposal is supported by an experiment in which 19 web applications have been analyzed.

SUMMARY Web applications are often used to expose business processes implemented as software systems. This paper describes a technique for recovering business processes based on a dynamic analysis of the applications behavior. The technique described here does not require any access to internal software artifacts of the application, such as source code or documentation. An initial process is inferred to by means of the analysis of execution traces, in which the execution of GUI elements such as forms and links is recorded. The recovered process is then abstracted by clustering its elements according to four different criteria: structural, page-based, dependency-based and semantical. A case study has been conducted with the aim of evaluating understandability and readability of the reverse engineered processes as well as the clustering techniques used in refining them. Copyright © 2010 John Wiley & Sons, Ltd.

In recent years, several design notations have been proposed to model domain-specific applications or reference architectures. In particular, Conallen has proposed the UML Web Application Extension (WAE): a UML extension to model Web applications. The aim of our empirical investigation is to test whether the usage of the Conallen notation supports comprehension and maintenance activities with significant benefits, and whether such benefits depend on developers ability and experience. This paper reports and discusses the results of a series of four experiments performed in different locations and with subjects possessing different experience-namely, undergraduate students, graduate students, and research associates-and different ability levels. The experiments aim at comparing performances of subjects in comprehension tasks where they have the source code complemented either by standard UML diagrams or by diagrams stereotyped using the Conallen notation. Results indicate that, although, in general, it is not possible to observe any significant benefit associated with the usage of stereotyped diagrams, the availability of stereotypes reduces the gap between subjects with low skill or experience and highly skilled or experienced subjects. Results suggest that organizations employing developers with low experience can achieve a significant performance improvement by adopting stereotyped UML diagrams for Web applications.

Legacy systems are often written in programming languages that support arbitrary variable overlays. When migrating to modern languages, the data model must adhere to strict structuring rules, such as those associated with an object oriented data model, supporting classes, class attributes and inter-class relationships. In this paper, we deal with the problem of automatically transforming a data model which lacks structure and relies on the explicit layout of variables in memory as defined by programmers. We introduce an abstract syntax and a set of abstract rewrite rules to describe the proposed approach in a language neutral formalism. Then, we instantiate the approach for the proprietary programming language that was used to develop a large legacy system we are migrating to Java.

Asynchronous Javascript And XML (AJAX) is a recent technology used to develop rich and dynamic Web applications. Different from traditional Web applications, AJAX applications consist of a single page whose elements are updated dynamically in response to callbacks activated asynchronously by the user or by a server message. On the one hand, AJAX improves the responsiveness and usability of a Web application, but on the other hand, it makes the testing phase more difficult. In this paper, our state-based testing technique, developed to test AJAX-based applications, is compared to existing Web testing techniques, such as white-box and black-box ones. To this aim, an experiment based on two case studies has been conducted to evaluate effectiveness and test effort involved in the compared Web testing techniques. In particular, the capability of each technique to reveal injected faults of different fault categories is analyzed in detail. The associated effort was also measured. The results show that state-based testing is complementary to the existing Web testing techniques and can reveal faults otherwise unnoticed or hard to reveal with the other techniques.

Aspect oriented programming aims at addressing the problem of the crosscutting concerns, i.e., those functionalities that are scattered among several modules in a given system. Aspects can be defined to modularize such concerns. In this work, we focus on a specific kind of crosscutting concerns, the scattered implementation of methods declared by interfaces that do not belong to the principal decomposition. We call such interfaces aspectizable. All the aspectizable interfaces identified within a large number of classes from the Java Standard Library and from three Java applications have been automatically migrated to aspects. To assess the effects of the migration on the internal and external quality attributes of these systems, we collected a set of metrics and we conducted an empirical study, in which some maintenance tasks were executed on the two alternative versions (with and without aspects) of the same system. In this paper, we report the results of such a comparison.

Current practice in Web application development is based on the skills of the individual programmers and often does not apply the principles of software engineering. The increasing economic relevance and internal complexity of the new generation of Web applications require that proper quality standards are reached and that development is kept under control. It is therefore likely that the formalization of the process followed while developing these applications will be one of the major research topics. In this paper we focus on Web application testing, a crucial phase when quality and reliability are a goal. Testing is considered in the wider context of the whole development process, for which an incremental/iterative model is devised. The processes behind the testing activities are analyzed considering the specificity of Web applications, for which the availability of a reference model is shown to be particularly important. The approach proposed in this paper covers the integration testing phase, which can take advantage of some features of Web applications (e.g., the http protocol employed), thus resulting in a higher level of automation with respect to traditional software. The testing processes described in this paper are supported by the prototype research tool TestWeb. This tool exploits a reverse engineered UML (Unified Modeling Language) model of the Web application to generate and execute test cases, in order to satisfy the testing criteria selected by the user. The usage of this tool will be presented with reference to a real-world case study.

To isolate and fix failures that occur in the field, after deployment, developers must be able to reproduce and investigate such failures in-house. In practice, however, bug reports rarely provide enough information to recreate field failures, thus making in-house debugging an arduous task. This task becomes even more challenging for programs whose input must adhere to a formal specification, such as a grammar. To help developers address this issue, we propose an approach for automatically generating inputs that recreate field failures in-house. Given a faulty program and a field failure for this program, our approach exploits the potential of grammar-guided genetic programming to iteratively find legal inputs that can trigger the observed failure using a limited amount of runtime data collected in the field. When applied to 11 failures of 5 real-world programs, our approach was able to reproduce all but one of the failures while imposing a limited amount of overhead.

Web applications have become key assets of our society, which depends on web applications for sectors like business, health-care, and public administration. Testing is the most widely used and effective approach to ensure quality and dependability of the software, including web applications. However, web applications are special as compared to traditional software, because they involve dynamic code creation and interpretation and because they implement a specific interaction mode, based on the navigation structure of the web application. Researchers have investigated approaches and techniques to automate web testing, dealing with the special features of web applications. This chapter contains a comprehensive overview of the research carried out in the last 10 years to support web testing with automated tools. We categorize the works available in the literature according to the specific web testing phase that they address. In particular, we first of all consider the works aiming at building a navigation model of the web application under test. In fact, such a model is often the starting point for test case derivation. Then, we consider the problem of input generation, because the traversal of a selected navigation path requires that appropriate input data are identified and submitted to the server during test execution. Metrics are introduced and used to assess the adequacy of the test cases constructed from the model. The last part of the chapter is devoted to very recent advancements in the area, focused on rich client web applications, which demand a specific approach to modeling and to test case derivation.

Traceability ensures that software artifacts of subsequent phases of the development cycle are consistent. Few works have so far addressed the problem of automatically recovering traceability links between object-oriented (OO) design and code entities. Such a recovery process is required whenever there is no explicit support of traceability from the development process. The recovered information can drive the evolution of the available design so that it corresponds to the code, thus providing a still useful and updated high-level view of the system. Automatic recovery of traceability links can be achieved by determining the similarity of paired elements from design and code. The choice of the properties involved in the similarity computation is crucial for the success of the recovery process. In fact, design and code objects are complex artifacts with several properties attached. The basic anchors of the recovered traceability links should be chosen as those properties (or property combinations) which are expected to be maintained during the transformation of design into code. This may depend on specific practices and / or the development environment, which should therefore be properly accounted for. In this paper different categories of basic properties of design and code entities will be analyzed with respect to the contribution they give to traceability recovery. Several industrial software components will be employed as a benchmark on which the performances of the alternatives are measured.

Low coupling between modules and high cohesion inside each module are the key features of good software design. This paper proposes a new approach to using concept analysis for module restructuring, based on the computation of extended concept subpartitions. Alternative modularizations, characterized by high cohesion around the internal structures that are being manipulated, can be determined by such a method. To assess the quality of the restructured modules, the trade-off between encapsulation violations and decomposition is considered, and proper measures for both factors are defined. Furthermore, the cost of restructuring is evaluated through a measure of distance between the original and the new modularizations. Concept subpartitions were determined for a test suite of 20 programs of variable size: 10 public-domain and 10 industrial applications. The trade-off between encapsulation and decomposition was measured on the resulting module candidates, together with an estimate of the cost of restructuring. Moreover, the ability of concept analysis to determine meaningful modularizations was assessed in two ways. First, programs without encapsulation violations were used as oracles, assuming the absence of violations as an indicator of careful decomposition. Second, the suggested restructuring interventions were actually implemented in some case studies to evaluate the feasibility of restructuring and to deeply investigate the code organization before and after the intervention. Concept analysis was experienced to be a powerful tool supporting module restructuring.

When designing a new application, experienced software engineers usually adopt solutions that have proven successful in previous projects. Such reuse of code organizations is seldom made explicit. Nevertheless, it represents important information, which can be extremely valuable in the maintenance phase by documenting the design choices underlying the implementation. In addition it can be reused whenever a similar problem is encountered. In this paper an approach for the inference of recurrent design patterns directly from the code is proposed. 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 three C++ applications for which the structural relations among classes led to the extraction of a set of 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 applications analyzed. Copyright © 2001 John Wiley & Sons, Ltd.

The ITC-Irst Reverse Engineering group was charged with analyzing a software application of approximately 4.7 million lines of C code. It was an old legacy system, maintained for a long time, on which several successive adaptive and corrective maintenance interventions had led to the degradation of the original structure. The company decided to re-engineer the software instead of replacing it, because the complexity and costs of re-implementing the application from scratch could not be afforded, and the associated risk could not be run. Several problems were encountered during re-engineering, including identifying dependencies and detecting redundant functions that were not used anymore. To accomplish these goals, we adopted a conservative approach. Before performing any kind of analysis on the whole code, we carefully evaluated the expected costs. To this aim, a small but representative sample of modules was preliminarily analyzed, and the costs and outcomes were extrapolated so as to obtain some indications on the analysis of the whole system. When the results of the sample modules were found to be useful as well as affordable for the entire system, the resources involved were carefully distributed among the different reverse engineering tasks to meet the customer's deadline. This paper summarizes that experience, discussing how we approached the problem, the way we managed the limited resources available to complete the task within the assigned deadlines, and the lessons we learned. Copyright © 2000 John Wiley & Sons, Ltd.

Program understanding activities are more difficult for programs written in languages (such as C) that heavily make use of pointers for data structure manipulation, because the programmer needs to build a mental model of the memory use and of the pointers to its locations. Pointers also pose additional problems to the tools supporting program understanding, since they introduce additional dependences that have to be accounted for. This paper extends the flow insensitive context insensitive points-to analysis (PTA) algorithm proposed by Steensgaard, to cover arbitrary combinations of pointer dereferences, array subscripts and field selections. It exhibits interesting properties, among which scalability resulting from the low complexity and good performances is one. The results of the analysis are valuable by themselves, as their graphical display represents the points-to links between locations. They are also integrated with other program understanding techniques like, e.g., call graph construction, slicing, plan recognition and architectural recovery. The use of this algorithm in the framework of the program understanding environment CANTO is discussed.

Web applications evolve at a very fast rate, to accommodate new functionalities, presentation styles and interaction modes. The test artefacts developed during web testing must be evolved accordingly. Among the other causes, one critical reason why test cases need maintenance during web evolution is that the locators used to uniquely identify the page elements under test may fail or may behave incorrectly. The robustness of web page locators used in test cases is thus critical to reduce the test maintenance effort. We present an algorithm that generates robust web page locators for the elements under test and we describe the design of an empirical study that we plan to execute to validate such robust locators.

Enriching business process models with semantic annotations that are taken from an ontology has become a crucial need in service provisioning, integration and composition, and business processes management. We represent semantically annotated business processes as part of an Web ontology lanuage knowledge base that formalizes the business process structure, the business domain, a set of criteria that describe correct semantic annotations, and a set of constraints that describe requirements on the business process itself. In this paper, we show how the Semantic Web representation and reasoning techniques can be 1) exploited by our aspect-oriented approach to modularize exception-handling (as well as other crosscutting) mechanisms and 2) effectively applied to formalize and automatically verify constraints on the management of exceptional flows (as well as other relevant flows) in business processes. The benefits of the Semantic Web and the aspect-oriented technologies are illustrated in a case study, where exceptional flows are modularized separately and managed at the semantic level due to the proposed approach.

The prioritization of requirements is a crucial activity in the early phases of the software development process. It consists of finding an order relation among requirements, considering several requirements characteristics, such as stakeholder preferences, technical constraints, implementation costs and user perceived value.We propose an interactive approach to the problem of prioritization based on Satisfiability Modulo Theory (SMT) techniques and pairwise comparisons. Our approach resorts to interactive knowledge acquisition whenever the relative priority among requirements cannot be determined based on the available information. Synthesis of the final ranking is obtained via SMT constraint solving.The approach has been evaluated on a set of requirements from a real healthcare project. Results show that it overcomes other interactive state-of-the-art prioritization approaches in terms of effectiveness, efficiency and robustness to decision maker errors.

The complexity of the technologies involved in the Future Internet makes testing extremely challenging and demands for novel approaches and major advancement in the field. The overall aim of the FITTEST project is to address these testing challenges, by developing an integrated environment for automated testing, which can monitor the Future Internet application under test and adapt to the dynamic changes observed. Future Internet applications do not remain fixed after their release, services and components can be dynamically added by customers. Consequently, FITTEST testing will be continuous and post-release such that maintenance and quality assurance can cope with the changes in the intended use of an application after release. The testing environment will integrate, adapt and automate various techniques for continuous Future Internet testing (dynamic model inference, model-based testing, log-based diagnosis, oracle learning, combinatorial testing, concurrent testing, regression testing).

Modern software systems have often the form of Web service compositions. They take advantage of the availability of a variety of external Web services to provide rich and complex functionalities, obtained as the integration of external services. However, Web services change at a fast pace and while syntactic changes are easily detected as interface incompatibilities, other more subtle changes are harder to detect and may give raise to faults. They occur when the interface is compatible with the composition, but the semantics of the service response has changed. This typically involves undocumented or implicit aspects of the service interface. Audit testing of services is the process by which the service integrator makes sure that the service composition continues to work properly with the new versions of the integrated services. Audit testing of services is conducted under strict (sometimes extreme) time and budget constraints. Hence, prioritizing the audit test cases so as to execute the most important ones first becomes of fundamental importance. We propose a test case prioritization method specifically tailored for audit testing of services. Our method is based on the idea that the most important test cases are those that have the highest sensitivity to changes injected into the service responses (mutations). In particular, we consider only changes that do not violate the explicit contract with the service (i.e., the WSDL), but may violate the implicit assumptions made by the service integrator.

The order in which requirements are implemented in a system affects the value delivered to the final users in the successive releases of the system. Requirements prioritization aims at ranking the requirements so as to trade off user priorities and implementation constraints, such as technical dependencies among requirements and necessarily limited resources allocated to the project. Requirement analysts possess relevant knowledge about the relative importance of requirements. We use an Interactive Genetic Algorithm to produce a requirement ordering which complies with the existing priorities, satisfies the technical constraints and takes into account the relative preferences elicited from the user. On a real case study, we show that this approach improves non interactive optimization, ignoring the elicited preferences, and that it can handle a number of requirements which is otherwise problematic for state of the art techniques.

As we observe in practice, software services act mostly as interface components that provide electronic access to the actual services behind, and the characteristics of these two types of services are very different. The fact that the user will eventually use or take part in actual services motivates us to shift our focus from software services to a more holistic view in order to better design user-centric services. In this paper we discuss the real service concept, which is composed of software and actual services, and the important factors regarding them. We, then, propose a methodology to support the designer in specifying real services and their design artifacts. Finally, we apply the proposed methodology to a motivating example and discuss its advantages as well as some open issues in light of our experience.

Semantic annotations are a way to provide a precise meaning to business process elements, which supports reasoning on properties and constraints. The specification and annotation of business processes is a complex activity involving different analysts possibly working on the same business process.

One of the challenges of testing web applications derives from their dynamic content and structure. As we test a website, we may discover more about its structure and behaviour. This paper proposes a framework for collection of testability measures during the automated testing process (termed ‘in-testing’ measure collection). The measures gathered in this way can take account of dynamic and content driven aspects of web applications, such as form structure, client-side scripting and server-side code. Their goal is to capture measurements related to on-going testing activity, indicating where additional testing can best lead to higher overall coverage. They denote a form of ‘web testability’ measures. The paper reports on the implementation of a prototype Web Application Testing Tool, WATT, illustrating the in-testing measure collection approach on 34 forms taken from 14 real world web applications.

AO4BPEL applied Aspect Oriented Programming to executable business processes. Although modularized, AO4BPEL aspects do not have an explicit interface and the implicit one, based on XPath, is often fragile, hence reusing aspects in different processes is quite hard. Cooperative Aspect Oriented Programming aims at making aspects reusable by means of cooperative work between base code and aspects, realized by increasing the explicit awareness of aspects at the expense of pure obliviousness. This work investigates the use of Cooperative Aspect Oriented Programming with BPEL processes.

One of the main reasons for the failure of many software projects is the late discovery of a mismatch between the customers' expectations and the pieces of functionality implemented in the delivered system. At the root of such a mismatch is often a set of poorly defined, incomplete, under-specified, and inconsistent requirements. Test driven development has recently been proposed as a way to clarify requirements during the initial elicitation phase, by means of acceptance tests that specify the desired behavior of the system. The goal of the work reported in this paper is to empirically characterize the contribution of acceptance tests to the clarification of the requirements coming from the customer. We focused on Fit tables, a way to express acceptance tests, which can be automatically translated into executable test cases. We ran two experiments with students from University of Trento and Politecnico of Torino, to assess the impact of Fit tables on the clarity of requirements. We considered whether Fit tables actually improve requirement understanding and whether this requires any additional comprehension effort. Experimental results show that Fit helps in the understanding of requirements without requiring a significant additional effort.

Business processes can be very large and may contain several different concerns, scattered across the process and tangled with other concerns. Crosscutting concerns are difficult to find and locate, thus making process design and evolution hard.

Business processes are often implemented by means of software systems which expose them to the user as an externally accessible Web application. This paper describes a technique for recovering business processes by dynamic analysis of the Web applications which ex-pose them. This approach does not require full access to internal software artifacts, such as source code or doc-umentation. The business process is instead inferred through analysis of the GUI-forms exercised by the user during the navigation in the Web application which ex-poses the process. The recovered process is then abstracted by clustering its business tasks according to structural or logical criteria.A preliminary experiment has been conducted with the aim of evaluating understandability and readability of the reverse engineered business processes.

Agent-Oriented Software Engineering (AOSE) methodologiesare proposed to develop complex distributed systems based uponthe agent paradigm. The natural implementation for such systems hasusually the form of Multi-Agent Systems (MAS). As these systems areincreasingly applied in mission-critical services, assurances need to begiven to their owners and users that they operate properly. Althoughthe relevance of the link between requirements engineering and testinghas long been recognized, current Agent-Oriented Software Engineeringmethodologies partially address it. Some of them offer specification-based formal verification, allowing software developers to correct errors at thebeginning of the development process, others exploits Object-Oriented (OO) testing techniques, upon a mapping of agent-oriented abstractionsinto OO constructs. However, a structured testing process for AOSEmethodologies that complements formal verification is still missing. In this paper we introduce a testing framework for the AOSE methodologyTropos. It specifies a testing process model that complements theagent-oriented requirements and design models and strengthens the mutualrelationship between goal analysis and testing. Furthermore, it providesa systematic way of deriving test cases from goal analysis. We callthis approach goal-oriented testing.

Legacy systems are often large and difficult to maintain, but rewriting them from scratch is usually not a viable option. Reenginering remains the only way to modernize them. We have been recently involved in a migration project aiming at porting an old, large (8 MLOC) legacy banking system to a modern architecture. The goal of the project is: (I) moving from an old, proprietary language to Java; (2) replacing ISAM indexed files with a relational database; (3) upgrading the character oriented interface to a modern GUI. One of the steps in the migration process deals with the elimination of unstructured code (unconditional jumps such as GOTO statements). In this paper we present four alternative strategies for GOTO elimination that we evaluated in the project. Each has pros and cons, but when used in a real case, it turned out that one produced completely unreadable code, hence it was discarded. The final choice was a combination of the three remaining strategies.

Test-driven software development tackles the problem of operationally defining the features to be implemented by means of test cases. This approach was recently ported to the early development phase, when requirements are gathered and clarified. Among the existing proposals, Fit (Framework for Integrated Testing) supports the precise specification of requirements by means of so called Fit tables, which express relevant usage scenarios in a tabular format, easily understood also by the customer. Fit tables can be turned into executable test cases through the creation of pieces of glue code, called fixtures. In this paper, we test the claimed benefits of Fit through a series of three controlled experiments in which Fit tables and related fixtures are used to clarify a set of change requirements, in a software evolution scenario. Results indicate improved correctness achieved with no significant impact on time, however benefits of Fit vary in a substantial way depending on the developers' experience. Preliminary results on the usage of Fit in combination with pair programming revealed another relevant source of variation.

Identifiers represent an important source of information for programmers understanding and maintaining a system. Self-documenting identifiers reduce the time and effort necessary to obtain the level of understanding appropriate for the task at hand. While the role of the lexicon in program comprehension has long been recognized, only a few works have studied the quality and enhancement of the identifiers and no works have studied the evolution of the lexicon. In this paper, we characterize the evolution of program identifiers in terms of stability metrics and occurrences of renaming. We assess whether an evolution process similar to the one occurring for the program structure exists for identifiers. We report data and results about the evolution of three large systems, for which several releases are available. We have found evidence that the evolution of the lexicon is more limited and constrained than the evolution of the structure. We argue that the different evolution results from several factors including the lack of advanced tool support for lexicon construction, documentation, and evolution.

The increasing demand for reliable Web applications gives a central role to Web testing. Most of the existing works are focused on the definition of novel testing techniques, specifically tailored to the Web. However, no attempt was carried out so far to understand the specific nature of Web faults. This is of fundamental importance to assess the effectiveness of the proposed Web testing techniques. In this paper, we describe the process followed in the construction of a Web fault taxonomy. After the initial, top- down construction, the taxonomy was subjected to four iterations of empirical validation aimed at refining it and at understanding its effectiveness in bug classification. The final taxonomy is publicly available for consultation and editing on a Wiki page. Testers can use it in the definition of test cases that target specific classes of Web faults. Researchers can use it to build fault seeding tools that inject artificial faults which resemble the real ones.

Software quality assessment of large COBOL industrial legacy systems, both for maintenance or migration purposes, mounts a serious challenge. We present the software quality assessment and visualisation toolset (SQuAVisiT), which assists users in performing the above task. First, it allows a fully automatic extraction of metrics, call information, and code duplication from COBOL source code. This information, stored into a database, can be easily converted and exported to a set of visualization tools. We incorporated several such third-party tools for the visualization of call relations and system structure, and metrics visualization. These tools use novel visualization techniques such as bundled edges, matrix plots, and table lens. We illustrate the usage of our toolset with an industrial case study on a COBOL system comprising about 3000 modules and 1.7 million lines of code.

Proponents of design notations tailored for specific application domains or reference architectures, often available in the form of UML stereotypes, motivate them by improved understandability and modifiability. However, empirical studies that tested such claims report contradictory results, where the most intuitive notations are not always the best performing ones. This indicates the possible existence of relevant influencing factors, other than the design notation itself. In this work we report the results of a family of three experiments performed at different locations and with different subjects, in which we assessed the effectiveness of UML stereotypes for Web design in support to comprehension tasks. Replications with different subjects allowed us to investigate whether subjects' ability and experience play any role in the comprehension of stereotyped diagrams. We observed different behaviors of users with different degrees of ability and experience, which suggests alternative comprehension strategies of (and tool support for) different categories of users.

Web application design requires the modeling of multiple, separate concerns, such as the navigational structure, the business logic and the data persistence. To this aim, several methodologies have been conceived. One of them, the Web Application Extension (WAE), extends the UML notation by means of stereotypes and tagged values intended to capture Web-specific concepts (e.g., the navigational structure). Although the WAE methodology is nowadays quite mature and ready for industrial adoption, the question whether it is able to actually facilitate the task of developers and maintainers has still to be empirically investigated. This paper reports and discusses the results from a controlled experiment on the benefits associated with the use of the WAE notation in the execution of comprehension tasks, carried out before maintenance. The WAE notation was compared against the use of pure unified modified language. Results indicate that the use of the WAE notation significantly improves the level of comprehension, although it does not increase the time needed to perform the comprehension task in a significant way. Copyright © 2007 John Wiley & Sons, Ltd.

AAA 2006 is the first Astrenet Aspect Analysis workshop, a workshop that brings together the Aspect Oriented Software Development community and the community currently gathered under the ASTReNet network namely: Program Analysis, Slicing and Transformation. The workshop, held in Benevento, Italy, brings together these two groups to listen to expert researchers, panelists and keynotes and to discuss state-of-the-art tools, techniques and ideas from both industry and academia to both consolidate pre-existing research and inspire new research ideas.

Understanding a software system at source-code level requires understanding the different concerns that it addresses, which in turn requires a way to identify these concerns in the source code. Whereas some concerns are explicitly represented by program entities (like classes, methods and variables) and thus are easy to identify, crosscutting concerns are not captured by a single program entity but are scattered over many program entities and are tangled with the other concerns. Because of their crosscutting nature, such crosscutting concerns are difficult to identify, and reduce the understandability of the system as a whole. In this paper, we report on a combined experiment in which we try to identify crosscutting concerns in the JHotDraw framework automatically. We first apply three independently developed aspect mining techniques to JHotDraw and evaluate and compare their results. Based on this analysis, we present three interesting combinations of these three techniques, and show how these combinations provide a more complete coverage of the detected concerns as compared to the original techniques individually. Our results are a first step towards improving the understandability of a system that contains crosscutting concerns, and can be used as a basis for refactoring the identified crosscutting concerns into aspects., 28 pages

Comprehension of Web applications is a complex task, since several concerns co-exist in their implementation, among which the business logic, the navigation structure (as supported by hyperlinks and form submission), and persistent data storage. Design notations tailored for Web applications promise increased understandability and maintainability, thanks to the explicit representation of Web specific elements (such as hyperlinks and forms). In this paper, we report the results obtained from the execution of an empirical study involving comprehension tasks on two Web applications. Assuming the availability of the source code, two forms of design diagrams have been recovered from the code: standard UML diagrams and UML diagrams extended with Conallen?s stereotypes. The research question addressed by this study is whether enriching standard UML diagrams with Web specific stereotypes gives any significant contribution to the understandability of the Web applications.

Aspect-oriented programming (AOP) provides mechanisms for the separation of crosscutting concerns - functionalities scattered through the system and tangled with the base code. Existing systems are a natural testbed for the AOP approach since they often contain several crosscutting concerns which could not be modularized using traditional programming constructs. This paper presents an automated approach to the problem of migrating systems developed according to the object-oriented programming (OOP) paradigm into aspect-oriented programming (AOP). A simple set of six refactorings has been defined to transform OOP to AOP and has been implemented in the AOP-migrator tool, an Eclipse plug-in. A set of enabling transformations from OOP to OOP complement the initial set of refactorings. The paper presents the results of four case studies, which use the approach to migrate selected crosscutting concerns from medium-sized Java programs (in the range of 10K to 40K lines of code) into equivalent programs in AspectJ. The case study results show the feasibility of the migration and indicate the importance of the enabling transformations as a preprocessing step

The quality delivered by existing Web applications is often poor. A consequence of this situation is a strong demand for techniques and tools that address the problem of the Web application quality. Lots of approaches are currently available, often coming with prototype or commercial tools implementing them. However, no attempt has been made so far to validate their effectiveness. In this paper, we consider the available techniques for Web testing and we propose a classification into three major groups. We deal with the problem of defining the Web-specific faults. Our approach is an empirical investigation of the reported faults, abstracted into a fault model. Then, we evaluate the available techniques against the fault model, in terms of the fault categories directly addressed by them. Finally, we sketch a roadmap for the future empirical research.

White-box testing exercises a software system by ensuring that a model of the internal structure is covered by the test cases. Extending this approach to Web applications is far from obvious, because at least two abstraction levels can be considered to represent the internal structure of a Web application: the navigation model and the control flow model. To further complicate the matter, dynamic code generation must be taken into account in both models. In this paper, the two alternative models are presented and white-box testing criteria are defined on them. Their usage for the white-box testing of a real-world Web application is described, highlighting the associated costs and benefits.

The field of reverse engineering, originally tied to the analysis and restructuring of legacy systems, proved to be equally effective in supporting the evolution of modern software systems (e.g., OO code, Web applications, etc.). Correspondingly, a high number of techniques and tools have been developed to address the program comprehension needs of the programmers facing maintenance tasks on any kind of software. So far, the validation of the proposed approaches consisted mainly of proofs of concepts and limited case studies. The aim of this workshop was to assess the role of the empirical studies in the future developments of reverse engineering. Knowledge on the actual effectiveness of the available techniques and tools can be gained only through controlled experimentation. In this workshop, the scope of investigation of such studies was considered, and a (provisional) reference taxonomy of tools and techniques was discussed. Then, the main features of the empirical studies specifically designed to validate reverse engineering tools or techniques have been thoroughly examined

This paper presents a human-guided automated approach to refactoring object oriented programs to the aspect oriented paradigm. The approach is based upon the iterative application of four steps: discovery, enabling, selection, and refactoring. After discovering potentially applicable refactorings, the enabling step transforms the code to improve refactorability. During the selection phase the particular refactorings to apply are chosen. Finally, the refactoring phase transforms the code by moving the selected code to a new aspect. This paper presents the results of an evaluation in which one of the crosscutting concerns of a 40,000 LoC program (JHotDraw) is refactored.

This chapter aims at providing a presentation of the principles and techniques involved in the (semi-)automatic transformation of Web applications, in several different restructuring contexts. The necessary background knowledge is provided to the reader in the sections about the syntax of the multiple languages involved in Web application development and about the role of restructuring in a highly dynamic and rapidly evolving development environment. Then, specific examples of Web restructuring are described in detail. In the presentation of the transformations required for restructuring, as well as in the description of the grammar for the involved languages, TXL (Cordy, Dean, Malton & Schneider, 2002) and its programming language is adopted as a unifying element. The chapter is organized into the following sections: in the section following the Introduction, the problems associated with the analysis of the multiple languages used with Web applications are discussed. Then, the process of Web application restructuring is considered. Three examples of Web restructuring are described in more detail in the next three sections (design restructuring, migration of a static Web site to a dynamic Web application, consistency among monolingual portions of a multilingual Web site). Related works and concluding remarks are at the end of the chapter.

During software evolution, programmers spend a lot of time and effort in the comprehension of the internal code structure. Such an activity is often required because the available documentation is not aligned with the implementation, if not missing at all. In order to avoid wasting the time devoted to this activity, programmers can record the knowledge they have gained in the form of multiple, structural views that address the specific aspects of the system that they have considered. Re-documentation of existing software through design views can be achieved either using a drawing editor or annotating the source code. In the first case, diagrams are produced interactively, starting from the reverse engineered information. In the second case, diagrams are produced by an annotation processing tool. Most of current reverse engineering tools fall into the first case but they have serious limitations in the information they can recover automatically and they eventually require human intervention. The aim of the empirical work reported in this paper is the comparison of these two approaches, in order to understand which is easier to use and which the current limitations of both of them are