Mario Luca Bernardi

Recovering conceptual models from web applications

This paper proposes a reverse engineering approach for abstracting conceptual user-centered models from existing Web applications to re-document them at a high level of abstraction and from a user perspective.The recovered models are specified by referring to the Ubiquitous Web Application (UWA) design methodology. UWA models are able to describe the structure of the application contents, the semantic relations among contents, the different views on contents the application offers to users, and the navigation paths and the navigation nodes used to present contents to users.The approach exploits existing reverse engineering methods and tools to extract fine grained structural information from the analyzed applications and abstracts UWA models from them.The architecture of a tool to support the reverse engineering approach is described and the results from some preliminary experiments are discussed.

Testing Aspect Oriented Programs: an Approach Based on the Coverage of the Interactions among Advices and Methods

Testing is a fundamental issue to ensure software quality. Testing aspect oriented programs may be more difficult than traditional ones, due to the large impact that aspects have on the static structure and dynamic behavior of the overall system. Aspects may be sources for failures due to new kinds of faults in their code, by affecting the overall quality of the system. New testing approaches and criteria, taking into account the aspect-oriented constructs, are needed to capture the new kind of program failures. In this paper we propose a set of testing coverage criteria based on the interactions among the advices and the methods they affect. The proposed criteria are based on the inter-procedural aspect control flow graph (IACFG) representing the inter-procedural interactions among advices and methods.

Generating Event Logs Through the Simulation of Declare Models

In the process mining field, several techniques have been developed during the last years, for the discovery of declarative process models from event logs. This type of models describes processes on the basis of temporal constraints. Every behavior that does not violate such constraints is allowed, and such characteristic has proven to be suitable for representing highly flexible processes. One way to test a process discovery technique is to generate an event log by simulating a process model, and then verify that the process discovered from such a log matches the original one. For this reason, a tool for generating event logs starting from declarative process models becomes vital for the evaluation of declarative process discovery techniques. In this paper, we present an approach for the automated generation of event logs, starting from process models that are based on Declare, one of the most used declarative modeling languages in the process mining literature. Our framework bases upon the translation of Declare constraints into regular expressions and on the utilization of Finite State Automata for the simulation. An evaluation of the implemented tool is presented, showing its effectiveness in both the generation of new logs and the replication of the behavior of existing ones. The presented evaluation also shows the capability of the tool of generating very large logs in a reasonably small amount of time, and its integration with state-of-the-art Declare modeling and discovery tools.

Using Declarative Workflow Languages to Develop Process-Centric Web Applications

Nowadays, process-centric Web Applications (WAs) are extensively used in contexts where multi-user, coordinated work is required. Recently, Model Driven Engineering (MDE) techniques have been investigated for the development of this kind of applications. However, there are still some open issues. First, a complete roundtrip engineering support is still missing. Second, the lack of a proper integration of the existing MDE methodologies with workflow modeling techniques does not allow the developers to model the components of a WA in a compact and easy way. Third, the existing MDE approaches are based on procedural languages and not on declarative languages, even if these are more suitable to describe processes characterized by high variability. To address these issues, in this paper, we adopt a conservative approach to roundtrip engineering for the development of process-centric WAs and propose the integration of three MDE metamodels used to represent the main components of a WA with the metamodel of Declare, a declarative language to represent business processes. The proposed approach has been used to develop an online system for visit reservation in a hospital in order to validate its feasibility, correctness and effectiveness.

A model-driven approach for the fast prototyping of web applications

This paper presents an approach for the model-driven fast prototyping of Web applications. The approach exploits well known Model-Driven Engineering frameworks and technologies, such as Eclipse EMF, GMF, and Xpand, to enable the design of a Web application and the automatic generation of the code artifacts implementing a ready to deploy prototype of it. The approach allows to effortlessly and quickly carry out a modeling-generation-validation process in order to validate and refining the design of a Web application before actually implementing it. The paper describes the approach and the process followed to define it, the supporting tools and the technologies used to develop them, and the results from a case study of designing and generating the prototype of a Web application for on-line note taking and sharing. The process and the technologies used to develop the proposed approach can be reused to develop a fast prototyping approach for a different design model and a different target technology platform.

Model-driven detection of Design Patterns

Tracing source code elements of an existing Object Oriented software system to the components of a Design Pattern is a key step in program comprehension or re-engineering. It helps, mainly for legacy systems, to discover the main design decisions and trade-offs that are often not documented. In this paper an approach is presented to automatically detect Design Patterns in existing Object Oriented systems by tracing systems source code components to the roles they play in the Patterns. Design Patterns are modelled by high level structural Properties (e.g. inheritance, dependency, invocation, delegation, type nesting and membership relationships) that are checked, by source code parsing, against the system structure and components. The approach allows to detect also Pattern variants, defined by overriding the Pattern structural properties. The approach was applied to some open-source systems to validate it. Results on the detected patterns, discovered variants and on the overall quality of the approach are provided and discussed.

The RE-UWA approach to recover user centered conceptual models from Web applications

Large-scale Web Applications, especially those intended to publish contents and provide information to its users, are by nature subject to continuous and fast changes. This often means fast obsolescence of the design documentation and a lot of effort required to comprehend the application when performing maintenance and evolution tasks. This paper presents a reverse engineering approach for Web Applications enabling the semi-automatic recovery of user-centered conceptual models describing, from a user perspective, key aspects, such as the delivered contents and navigational paths. The abstracted models are formalized according to the Ubiquitous Web Applications (UWA) design methodology, but any other design method for Web Applications could be used instead. The paper describes the recovery process, a tool developed to support the process, and the results from a case study conducted to validate the approach on a set of real world Web Applications.

A model-driven graph-matching approach for design pattern detection

In this paper an approach to automatically detect Design Patterns (DPs) in Object Oriented systems is presented. It allows to link systems source code components to the roles they play in each pattern. DPs are modelled by high level structural properties (e.g. inheritance, dependency, invocation, delegation, type nesting and membership relationships) that are checked against the system structure and components. The proposed metamodel also allows to define DP variants, overriding the structural properties of existing DP models, to improve detection quality. The approach was validated on an open benchmark containing several open-source systems of increasing sizes. Moreover, for other two systems, the results have been compared with the ones from a similar approach existing in literature. The results obtained on the analyzed systems, the identified variants and the efficiency and effectiveness of the approach are thoroughly presented and discussed.

Web applications design recovery and evolution with RE‐UWA

This paper presents a semi‐automatic approach for the recovery and evolution of the design of existing Web applications. The proposed approach is structured in two main phases and is based on the Ubiquitous Web Applications (UWA) design framework, a methodology and a set of models and tools for the user‐centered design of multichannel context‐aware Web applications. In the first phase a representative set of the applications front‐end Web pages are analyzed to abstract the ‘as‐is’ design model of the application according to the UWA methodology. In the second phase, the recovered design model is evolved to define the ‘to be’ version of it. This evolution activity considers the up‐to‐date requirements available for the application and UWA design guidelines to identify shortcomings and opportunities of improvement in the ‘as‐is’ design. The reverse modeling phase exploits clustering and clone detection techniques and is supported by the RE‐UWA tool, an Eclipse IDE customized to implement the reverse engineering process defined to extract formal UWA models expressed as instances of a MOF metamodel. The forward design phase is supported by a set of UWA modeling tools that are built on top of the Eclipse Modeling Framework (EMF) and the Eclipse Graphical Modeling Framework (GMF). The proposed design recovery and evolution approach is applied to four real‐world Web applications and the obtained results are also presented in the paper. Copyright

M3D: a tool for the model driven development of web applications

Nowadays, Web Applications (WAs) are complex software systems, used by multiple users with different roles and often developed to support and manage business processes. Due to the changing nature of the supported processes, WAs need to be easily and quickly modified, to adapt and align them to the processes they support. In recent years, Model Driven Engineering (MDE) approaches have been proposed and used to develop and evolve WAs. However, the definition of appropriate MDE approaches for the development of flexible process-centric WAs is still limited. In particular, (flexible) workflow models have never been integrated with the models (e.g., presentation, information models) used in MDE approaches to develop this type of applications. In this paper, we present M3D (Model Driven Development with Declare), a tool for developing WAs that integrates three MDE metamodels used to represent the main components of a WA with the metamodel of Declare, a declarative language to model business processes. The tool exploits and combines the declarative nature of Declare and the advantages of MDE to get an efficient roundtrip engineering support to develop and evolve flexible process-centric WAs.