Stefania Leone

Crowdsourced web engineering and design

We present an approach for the lightweight development of web information systems based on the idea of involving crowds in the underlying engineering and design processes. Our approach is designed to support developers as well as non-technical end-users in composing data-driven web interfaces in a plug-n-play manner. To enable this, we introduce the notion of crowdsourced web site components whose design can gradually evolve as they get associated with more data and functionality contributed by the crowd. Hence, required components must not necessarily pre-exist or be developed by the application designer alone, but can also be created on-demand by publishing an open call to the crowd that may in response provide multiple alternative solutions. The potential of the approach is illustrated based on two initial experiments.

Exploiting Tag Clouds for Database Browsing and Querying

Querying and browsing of databases is a task exclusively done by experts that have mastered the query language and are familiar with a database’s schema. We show how tag clouds can be used alongside more traditional query languages and data visualisation techniques as a means for browsing and querying databases by both experts and non-expert users. Our approach is based on a general, extensible framework that supports different modes of visualisation as well as different database systems. We have validated our prototype with a user study that has shown how non-experts were able to browse and retrieve data that usually would only be possible by means of queries.

XCML: providing context-aware language extensions for the specification of multi-device web applications

There is a vast body of research dealing with the development of context-aware web applications that can adapt to different user, platform and device contexts. However, the range and growing diversity of new devices poses two significant problems to existing approaches. First, many techniques require a number of additional design processes and modelling steps before applications can be adapted. Second, the new generation of platforms and technologies underlying these devices as well as upcoming web standards HTML5 and CSS3 have partly changed the way in which web applications are implemented nowadays and often limit the way in which they can be adapted. In this paper, we present XCML as one example of a domain-specific language that tightly integrates context-aware concepts and adaptivity mechanisms to support developers in the specification and implementation of multi-channel web applications. In contrast to most existing approaches, the objective is to use a more lightweight approach to adaptation that can dynamically evolve and support new requirements as they emerge. Our solution builds on versioning principles in combination with a context matching process based on a declaration of context-dependent variants of content, navigation and presentation in terms of context expressions at different levels of granularity that are specific to the application. To support this, a formally defined context algebra is used to parse and resolve the context expressions at compile-time and to determine the best-matching variants with respect to the client context at run-time. We present the language concepts and a possible execution environment together with context-aware developer tools for the authoring and testing of adaptive features and behaviour. We also report on two case studies: the first shows how our general approach allows for integration with existing technologies to leverage advanced context-aware mechanisms in applications developed using other platforms and languages and the second how existing web interfaces can be systematically extended to support new adaptation scenarios.

Dynamic metamodel extension modules to support adaptive data management

Databases are now used in a wide variety of settings resulting in requirements which may differ substantially from one application to another, even to the point of conflict. Consequently, there is no database product that can support all forms of information systems ranging from enterprise applications to personal information systems running on mobile devices. Further, domains such as the Web have demonstrated the need to cope with rapidly evolving requirements. We define dynamic metamodel extension modules that support adaptive data management by evolving a system in the event of changing requirements and show how this technique was applied to cater for specific application settings.

Integrating component-based web engineering into content management systems

Popular content management systems such as WordPress and Drupal offer a plug-in mechanism that allows users to extend the platform with additional functionality. However, plug-ins are typically isolated extensions defining their own data structures, application logic and user interface, and are difficult to combine. We address the fact that users may want to configure their applications more freely through the composition of such extensions. We present an approach and model for component-based web engineering based on the concept of components and connectors between them, supporting composition at the level of the schema and data, the application logic and the user interface. We show how our approach can be used to integrate component-based web engineering into platforms such as WordPress. We demonstrate the benefits of the approach by presenting a composition plug-in that showcases component composition through configurable connectors based on an eCommerce application scenario.

A meta-plugin for bespoke data management in wordpress

WordPress is a powerful and extensible platform for web-based information publishing and management. While the WordPress core is targeted to the publication of chronologically ordered textual articles typical of blogs, users have developed plugins as well as themes to support the data management requirements of specific domains such as e-commerce or e-learning. However, the creation of such plugins requires development skills and effort. We present a meta-plugin that automatically generates bespoke plugins for data management based on user-defined ER models. We illustrate the approach using an example of creating a WordPress site for managing information about courses.

Building eCommerce systems from shared micro-schemas

We present an approach that supports the design of eCommerce systems in a modular way based on the composition of microschemas that are shared and reused within a community. We have designed and developed a platform that supports platform users in composing their individual eCommerce systems through a process of selecting appropriate micro-schemas from the micro-schema repository, composing, extending and adapting them at the level of the application model.

Managing Personal Information through Information Components

We introduce the concept of information components and show how it can allow non-expert users to construct their personal information spaces by selecting, customising and composing components defined by the system or other users. The system presented is based on a plug-and-play concept where new user-defined applications can be created and integrated into the portal-style interface based on default templates which can easily be customised by the users.

Adaptive Model-Driven Information Systems Development for Object Databases

Modern information system development faces the problem that applications may have to run on a large number of platforms with vastly different capabilities and resources, often ranging from mobile devices to desktop computers and further. This is particularly true of information systems based on object database technologies which nowadays are used at both ends of the spectrum with embedded systems as well as massive scientific databases among their target domains.

Optimising schema evolution operation sequences in object databases for data evolution

We propose an approach to optimising schema evolution operation sequences in object databases. The approach separates operations that add structures from those that remove structures so that all additions are performed before any removals. This separation ensures that there is always a state during schema evolution where data can be evolved from structures that are to be deleted to structures that are new or already exist. Our approach also reduces and groups the schema operations to simplify implementation of data evolution functions by developers. We present a case study used as a first evaluation of the approach.