Esteban Robles Luna

Mockup-Driven Development: Providing agile support for Model-Driven Web Engineering

Context: Agile software development approaches are currently becoming the industry standard for Web Application development. On the other hand, Model-Driven Web Engineering (MDWE) methodologies are known to improve productivity when building this kind of applications. However, current MDWE methodologies tend to ignore important aspects of Web Applications development supported by agile processes, such as constant customer feedback or early design of user interfaces. Objective: In this paper we analyze the difficulties of supporting agile features in MDWE methodologies. Then, we propose an approach that eases the incorporation of well-known agile practices to MDWE. Method: We propose using User Interface prototypes (usually known as mockups) as a way to start the modeling process in the context of a mixed agile-MDWE process. To assist this process, we defined a lightweight metamodel that allows modeling features over mockups, interacting with end-users and generating MDWE models. Then, we conducted a statistical evaluation of both approaches (traditional vs. mockup-based modeling). Results: First we comment on how agile features can be added to MDWE processes using mockups. Then, we show by means of a quantitative study that the proposed approach is faster, less error-prone and still as complete as traditional MDWE processes. Conclusion: The use of mockups to guide the MDWE process helps in the reduction of the development cycle as well as in the incorporation of agile practices in the model-driven workflow. Complete MDWE models can be built and generated by using lightweight modeling over User Interface mockups, and this process suggests being more efficient, in terms of errors and effort, than traditional modeling in MDWE.

WebSpec: a visual language for specifying interaction and navigation requirements in web applications

Web application development is a complex and time-consuming process that involves different stakeholders (ranging from customers to developers); these applications have some unique characteristics like navigational access to information, sophisticated interaction features, etc. However, there have been few proposals to represent those requirements that are specific to Web applications. Consequently, validation of requirements (e.g., in acceptance tests) is usually informal and as a result troublesome. To overcome these problems, we present WebSpec, a domain-specific language for specifying the most relevant and characteristic requirements of Web applications: those involving interaction and navigation. We describe WebSpec diagrams, discussing their abstraction and expressive power. With a simple though realistic example, we show how we have used WebSpec in the context of an agile Web development approach discussing several issues such as automatic test generation, management of changes in requirements, and improving the understanding of the diagrams through application simulation.

Towards Agile Model-Driven Web Engineering

The increasing growth of the Web field has promoted the development of a plethora of Model-Driven Web Engineering (MDWE) approaches. These methodologies share a top-down approach: they start by modeling application content, then they define a navigational schema, and finally refine the latter to obtain presentation and rich behavior specifications. Such approach makes it difficult to acquire quick feedback from customers. Conversely, agile methods follow a non-structured, implementation-centered process building software prototypes to get immediate feedback. In this work we propose an agile approach to MDWE methodologies (called Mockup-Driven Development, or MockupDD) by inverting the development process: we start from user interface mockups that facilitate the generation of software prototypes and models, then we enrich them and apply heuristics in order to obtain software specifications at different abstraction levels. As a result, we get an agile prototype-based iterative process, with advantages of a MDWE one.

From interface mockups to web application models

The process of modeling and implementing Web applications has been successfully improved by the use of Model-Driven Web Engineering (MDWE) methodologies. However, because of their traditional process models, these methodologies delay the generation of application prototypes until all design aspects (e.g. domain and navigation) are completed. These aspects are crucial for developers but not for customers, who are interested in viewing parts of the application running as early as possible. In this paper we introduce a novel model driven approach that starts from user interface specifications, using mockups to derive concrete presentation implementations -- we call it Mockup-Driven Development or just MockupDD. Then, by using lightweight enrichments and applying heuristics over these models, we show how we obtain navigation and content specifications in the context of different MDWE methods.

A flexible tool suite for change-aware test-driven development of web applications

Though Web Applications development fits well with Test-Driven Development, there are some problems that hinder its success. In this demo we present a tool suite to improve TDD; the suite supports the representation of web requirements using a domain-specific language and the automatic generation of interaction tests among others.

Capturing and validating personalization requirements in Web applications

Personalization is a key feature to improve user experience in Web applications and therefore many Web engineering approaches allow the specification of some type of personalization when modelling a website. However, these approaches usually neglect the process of capturing and representing personalization requirements, thus not considering them when the application evolves; maintenance of these requirements is then a very complex task. In this paper, we present WebSpec, a requirement artefact used to capture navigation, interaction and interface aspects of Web applications. Concretely, we focus on how to specify personalization requirements, and on how to automatically generate the personalization model from their specification. Furthermore, from the requirements specification we derive a set of interaction tests to assess the personalization functionality. We illustrate our ideas with an E-commerce application example and describe a prototype tool which implements the described functionality.

Dealing with Navigation and Interaction Requirements Changes in a TDD-Based Web Engineering Approach

Web applications are well suited to be developed with agile methods. However, as they tend to change too fast, special care must be put in change management, both to satisfy customers and reduce developers load. In this paper we discuss how we deal with navigation and interaction requirements changes in a novel test-driven development approach for Web applications. We present it by indicating how it resembles and differs from “conventional” TDD, and showing how changes can be treated as “first class” objects, allowing us to automate the application changes and also to adaptively prune the test suite.

Improving user involvement through a model-driven requirements approach

Model-Driven Web Engineering (MDWE) methodologies have proven to be a mature way of developing web applications, dramatically increasing productivity during development. However, after more than a decade of evolution, the artifacts and processes used to gather requirements have not changed substantially. At the same time, the capacity of quickly adapting to emergent domain-specific requirements (a feature that became popular with the massive adoption of agile approaches) has become hard to achieve in these methodologies. In this context, in order to implement this kind of refined requirements as fast as possible, changes are usually applied directly to the generated application, losing the abstraction and its inherent productivity provided by the Model-Driven process. Another way of implementing this kind of changes is by extending the modeling language, but this implies a high effort and, again, a consequent productivity loss. In this paper we propose a model-driven development approach called MockRE that captures requirements using User Interface prototypes (mockups) that end-users can understand completely. The process and tooling presented here allows end-users to express requirements annotating the mockups with textual descriptions, and also generating a running application in the same way that MDWE environments do. Developers may later use these initial specifications placed by end-users as valuable model concepts that can be refined through direct coding in a non-intrusive way. Through this strategy, MockRE intends to make a more extensive reuse of end-users specifications throughout the whole developing process.

Modelling the Requirements of Rich Internet Applications in WebRe

In the last years, several Web methodological approaches were defined in order to support the systematic building of Web software. Together with the constant technological advances, these methods must be constantly improved to deal with a myriad of new feasible application features, such as those involving rich interaction features. Rich Internet Applications (RIA) are Web applications exhibiting interaction and interface features that are typical in desktop software. Some specific methodological resources are required to deal with these characteristics. This paper presents a solution for the treatment of Web Requirements in RIA development. For this aim we present WebRE+, a requirement metamodel that incorporates RIA features into the modelling repertoire. We illustrate our ideas with a meaningful example of a business intelligence application.

An Extensible, Model-Driven and End-User Centric Approach for API Building

The implementation of APIs in new applications is becoming a mandatory requirement due to the increasing use of cloud-based solutions, the necessity of integration with ubiquitous applications (like Facebook or Twitter) and the need to facilitate multi-platform support from scratch in the development. However, there is still no theoretically sound process for defining APIs (starting from end-user requirements) or their productive development and evolution, which represents a complex task. Moreover, high-level solutions intended to boost productivity of API development (usually based on Model-Driven Development methodologies) are often difficult to adapt to specific use cases and requirements. In this paper we propose a methodology that allows capturing requirements related to APIs using end-user-friendly artifacts. These artifacts allow quickly generating a first running version of the API with a specific architecture, which facilitates introducing refinements in it through direct coding, as is commonly accomplished in code-based Agile processes.