Firecrow is a tool for Web application analysis and reuse, which implements the functionalities of:
feature identification, automatic scenario generation, and feature reuse, in the context of client-side
web applications. The tool is in prototype stage and is available at github.
Web applications are one of the fastest growing types of software systems today. Structurally, they are composed out of two parts: the server-side, used for data-access and business logic, and the client-side used as a user-interface. In recent years, thanks to fast, modern web browsers and advanced scripting techniques, developers are building complex interfaces, and the client-side is playing an increasingly important role.From the user's perspective, the client-side offers a number of features. A feature is an abstract notion representing a distinguishable part of the system behavior. Similar features are often used in a large number of web applications, and facilitating their reuse would offer considerable benefits. However, the client-side technology stack does not offer any widely used structured reuse method, and code responsible for a feature is usually copy-pasted to the new application. Copy-paste reuse can be complex and error prone - usually it is hard to identify exactly the code responsible for a certain feature and introduce it into the new application without errors.The primary focus of the research described in this PhD thesis is to provide methods and tools for automatizing reuse in client-side web application development. This overarching problem leads to a number of sub-problems: i) how to identify code responsible for a particular feature; ii) how to include the code that implements a feature into an already existing application without breaking neither the code of the feature nor of the application; and iii) how to automatically generate sequences of user actions that accurately capture the behavior of a feature? In order to tackle these problems we have made the following contributions: i) a client-side dependency graph that is capable of capturing dependencies that exist in client-side web applications, ii) a method capable of identifying the exact code and resources that implement a particular feature, iii) a method that can introduce code from one application into another without introducing errors, and iv) a method for generating usage scenarios that cause the manifestation of a feature. Each contribution was evaluated a suite of web applications, and the evaluations have shown that each method is capable of performing its intended purpose.
A client-side application offers a number of features, and similar features are often used in a large number of web applications - facilitating reuse could offer considerable benefits in terms of faster development. Unfortunately, due to the specifics of prevailing technologies, the techniques and tools used to support reuse are not as advanced as in other software engineering disciplines -- the main method of reuse is still copy-pasting code. Copy-paste reuse can introduce a number of different types of errors that are time-consuming to detect and fix. In this paper we present a method for performing feature reuse in client-side web applications. We identify problems that occur when introducing code from one application into another application, present a set of algorithms that detect and fix those problems and perform the actual code merging. We have evaluated the approach on a web application suite, and the evaluation has shown that the method is capable of performing feature reuse.
Web applications are one of the fastest growing types of software systems today. Structurally, they are composed out of two parts: the server side, used for data-access and business logic, and the client-side used as a user-interface. In recent years, with developers building complex interfaces, the client side is playing an increasingly important role. Unfortunately, the techniques and tools used to support development are not as advanced as in other disciplines. From the userÂ’s perspective, the client-side offers a number of features that are relatively easy to distinguish. However, the same cannot be said for their implementation details. This makes code understanding, maintenance, and reuse difficult. The goal of the work presented in this paper is to improve reusability, maintainability and performance of client-side web applications by identifying the code that implements a particular feature. We have evaluated the approach based on three different experiments: extracting features, extracting library functionalities, and page optimization. The evaluation shows that the method is able to identify the implementation details of individual features, and that by extracting the identified code considerable savings in terms of code size and increased performance can be achieved.
Client-side web applications are highly-dynamic event-driven GUI applications where the majority of code is executed as a response to user-generated events. Many software engineering activities (e.g. testing) require sequences of actions (i.e. usage scenarios) that execute the application code with high coverage. these usage scenarios is a difficult and time-consuming activity. This is especially true when generating usage scenarios for a particular feature because it requires in-depth knowledge of application behavior and understanding of the underlying implementation. In this paper we present a method for automatic generation of feature usage scenarios. The method is based on dynamic analysis and systematic exploration of the application's event and value space. We have evaluated the approach in a case study, and the evaluation shows that the method is capable of identifying usage scenarios for a particular feature. We have also performed the evaluation on a suite of web applications, and the results show that an increase in coverage can be achieved, when compared to the initial coverage obtained by loading the page and executing registered events.