Josip Maras

Extracting client-side web application code

The web application domain is one of the fastest growing and most wide-spread application domains today. By utilizing fast, modern web browsers and advanced scripting techniques, web developers are developing highly interactive applications that can, in terms of user-experience and responsiveness, compete with standard desktop applications. A web application is composed of two equally important parts: the server-side and the client-side. The client-side acts as a user-interface to the application, and can be viewed as a collection of behaviors. Similar behaviors are often used in a large number of applications, and facilitating their reuse offers considerable benefits. However, due to client-side specifics, such as multi-language implementation and extreme dynamicity, identifying and extracting code responsible for a certain behavior is difficult. In this paper we present a semi-automatic method for extracting client-side web application code implementing a certain behavior. We show how by analyzing the execution of a usage scenario, code responsible for a certain behavior can be identified, how dependencies between different parts of the application can be tracked, and how in the end only the code responsible for a certain behavior can be extracted. Our evaluation shows that the method is capable of extracting stand-alone behaviors, while achieving considerable savings in terms of code size and application performance.

Identifying Code of Individual Features in Client-Side Web Applications

Web applications are one of todays fastest growing software systems. Structurally, they are composed 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 users 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 the understanding, maintenance, and reuse of code 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, a considerable reduction in code size and increase in performance can be achieved.

Generating feature usage scenarios in client-side web applications

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. Specifying 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 applications 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.

Reusing web application user-interface controls

Highly interactive web applications that offer user experience and responsiveness of desktop applications are becoming increasingly popular. They are often composed out of visually distinctive user-interface (UI) elements that encapsulate a certain behavior - the so called UI controls. Similar controls are often used in a large number of web pages, and facilitating their reuse could offer considerable benefits. Unfortunately, because of a very short time-to-market, and a fast pace of technology development, preparing controls for reuse is usually not a primary concern. In this paper we present a semi-automatic method, and the accompanying tool, for extracting and reusing web controls. The developer selects the control and performs a series of interactions that represent the behavior he/she wishes to reuse. In the background, the execution is analyzed and all code and resources necessary for the stand-alone functioning of the control are extracted. Optionally, the user can immediately reuse the extracted control by automatically embedding it in an already existing page.

Client-side web application slicing

Highly interactive web applications that offer user experience and responsiveness of standard desktop applications are becoming prevalent in the web application domain. However, with these benefits come certain drawbacks. For example, the event-based architectural style, and poor support for code organization, often lead to a situation where code responsible for a certain behavior is intermixed with irrelevant code. This makes development, debugging and reuse difficult. One way of locating code implementing a certain behavior is program slicing, a method that, given a subset of a programs behavior, reduces the program to a minimal form that still produces that behavior. In this paper we present a semi-automatic client-side web application slicing method, describe the web page dependency graph, and show how it can be used to extract only the code implementing a certain behavior.

PRIDE - An Environment for Component-Based Development of Distributed Real-Time Embedded Systems

Settling down the software architecture for embedded system is a complex and time consuming task. Specific concerns that are generally issued from implementation details must be captured in the software architecture and assessed to ensure system correctness. The matter is further complicated by the inherent complexity and heterogeneity of the targeted systems, platforms and concerns. In addition, tools capable of conjointly catering for the complete design-verification deployment cycle, extra-functional properties and reuse are currently lacking. To address this, we have developed Pride, an integrated development environment for component-based development of embedded systems. Pride is based on an architecture relying on components with well-defined semantics that serve as the central development entity, and as means to support and aggregate various analysis and verification techniques throughout the development -- from early specification to synthesis and deployment. Pride also provides generic support for integrating extra-functional properties into architectural definitions.

Comparing Theoretical and Experimental Results in Gen2 RFID Throughput

Radio frequency identification (RFID) technology, based on wireless communication between a reader and tags, is the most popular technology for indoor item identification and tracking. Among competing RFID technologies, Gen2 has emerged as the most popular one, due to the best price/performance ratio. In order to communicate with multiple tags, Gen2 RFID systems use dynamic frame slotted ALOHA (DFSA) as a medium access control (MAC) mechanism. To maximize DFSA throughput simple calculations show that the number of tags should equal the DFSA frame size. However, the number of tags in an environment is usually unknown and has to be estimated. So far, significant effort has been invested in estimating the correct number of tags. However, to the best of our knowledge, no one has explored the estimator performance in a real RFID measuring scenario. In this paper, we evaluate the throughput of a real RFID system by using the Software Defined Radio (SDR) technology. Our results show that phenomena related to radio waves propagation and reception have a significantly bigger influence on Gen2 RFID throughput than traditional approaches take into account.

15 years of CBSE symposium: impact on the research community

In 2012, the International Symposium on Component-based Software Engineering (CBSE) is being organized for the 15th time. This is a great opportunity to take a step back and reflect on the impact of the symposium over these 15 years. Several interesting questions immediately come to mind: What were the main topics of interest in the community? What is the maturity of the field? What is the research CBSE Symposia impact? Who are the mots involved researches and researchers centers? In order to answer these questions we have performed a systematic review of 318 papers published under CBSE. In this paper we provide answers about the impact of the event, list and categorize the most frequent topics, and give some statistical data about the event during this period.

Vision based wildfire and natural risk observers

Wildfires are natural risk phenomena that cause significant economic and environmental damage. In wildfire fighting strategy it is important to detect the wildfire in its initial stage and to apply, as soon as possible, the most appropriate fire fighting action. In both cases wildfire monitoring and surveillance systems are of great importance, so in the last decade the interest for various wildfire monitoring and surveillance systems has increased, both on the research and the implementation level. This paper describes one such system named iForestFire. It is an example of advanced terrestrial vision based wildfire monitoring and surveillance system, today widely used in various Croatian National and Nature Parks and regions, but it is also a system in constant development and improvement, both on theoretical and practical level. This paper describes its last improvements in video detection part that are based on notation of observer, cogent confabulation theory and mechanism of thought. Inclusion of cogent confabulation theory allows us to expend the use of existing wildfire observers to more general natural risk observers.

Extracting client-side web user interface controls

Web applications that are highly dynamic and interactive on the client side are becoming increasingly popular. As with any other type of applications, reuse offers considerable benefits. In this paper we present our first results on extracting easily reusable web user-interface controls. We have developed a tool called Firecrow that facilitates the extraction of reusable client side controls by dynamically analyzing a series of interactions, carried out by the developer, in order to extract the source code and the resources necessary for the reuse of the desired web user-interface control.