Matthias Heinrich

Exploiting single-user web applications for shared editing: a generic transformation approach

In the light of the Web 2.0 movement, web-based collaboration tools such as Google Docs have become mainstream and in the meantime serve millions of users. Apart from established collaborative web applications, numerous web editors lack multi-user support even though they are suitable for collaborative work. Enhancing these single-user editors with shared editing capabilities is a costly endeavor since the implementation of a collaboration infrastructure (accommodating conflict resolution, document synchronization, etc.) is required. In this paper, we present a generic transformation approach capable of converting single-user web editors into multi-user editors. Since our approach only requires the configuration of a generic collaboration infrastructure (GCI), the effort to inject shared editing support is significantly reduced in contrast to conventional implementation approaches neglecting reuse. We also report on experimental results of a user study showing that converted editors meet user requirements with respect to software and collaboration qualities. Moreover, we define the characteristics that editors must adhere to in order to leverage the GCI.

Rapid UI development for enterprise applications: combining manual and model-driven techniques

UI development for enterprise applications is a time-consuming and error-prone task. In fact, approximately 50% of development resources are devoted to UI implementation tasks [1]. Model-driven UI development aims to reduce this effort. However, the quality of the final layout is a problem of this approach, especially when dealing with large and complex domain models. We share our experience in successfully using model-driven UI development in a large-scale enterprise project. Our approach mitigates the problems of model-driven UI development by combining manual layout with automatic inference of UI elements from a given domain model. Furthermore, we provide means to influence the UI generation at design time and to customize the UI at runtime. Thus, our approach significantly reduces the UI implementation effort while retaining control of the resulting UI.

A platform to automatically generate and incorporate documents into an ontology-based content repository

In order to access large information pools efficiently data has to be structured and categorized. Recently, applying ontologies to formalize information has become an established approach. In particular, ontology-based search and navigation are promising solutions which are capable to significantly improve state of the art systems (e.g. full-text search engines). However, the ontology roll-out and maintenance are costly tasks. Therefore, we propose a documentation generation platform that automatically derives content and incorporates generated content into an existing ontology. The demanding task of classifying content as concept instances, setting data type and object properties is accomplished by the documentation generation platform. Eventually, our approach results in a semantically enriched content base. Note that no manual effort is required to establish links between content objects and the ontology.

Data binding for standard-based web applications

Development frameworks have proven to drive developer productivity and flourish in a variety of different application domains. For example, data binding frameworks supporting the process of associating User Interface (UI) elements and data objects can reduce implementation efforts significantly. Even so desktop application developers have access to a myriad of data binding frameworks (e.g. Eclipse JFace); Web development still lacks decent data binding framework support. Therefore, we devised a WebSocket-based Data-binding (WebSoDa) framework which is capable of easing the cumbersome and error-prone task of coupling UI elements with their respective data objects. Besides providing a Microdata-based data binding language, the WebSoDa framework embraces the WebSocket protocol. We show that the network traffic in data binding scenarios can decrease considerably by applying a WebSocket-based framework instead of a conventional AJAX approach.

MDA applied: a task-model driven tool chain for multimodal applications

Recently, industry has adopted multimodal, context-aware applications. However, addressing various modalities on heterogeneous platforms implies a demanding development effort. Therefore, we present a task-centric methodology and a tool chain leveraging the development of adaptive multimodal applications. In order to improve efficiency the tool chain is based on the Model Driven Architecture approach emphasizing two key principles: model-to-model transformations and tool integration.

WebSoDa: a tailored data binding framework for web programmers leveraging the WebSocket protocol and HTML5 Microdata

The data binding pattern is an established technique to couple user interface (UI) elements and data objects. Various markup languages (e.g. Microsoft XAML, Adobe MXML) integrate advanced data binding concepts in order to ease application development. However, the HTML standard does not embrace means for data binding although being the Web markup language supported by millions of Web programmers. Therefore, we propose a standard-compliant WebSocket-based Data Binding (WebSoDa) framework. The WebSoDa framework synchronizes data objects and UI elements by orchestrating a Microdata-based data binding language as well as a client-side and a server-side messaging component. Thus, developers may speed up the tedious task of implementing binding associations in Web applications.

Enriching web applications with collaboration support using dependency injection

Web-based collaboration tools such as Google Docs are pervasive in our daily lives since they have proven to efficiently support joint work of distributed teams. Nevertheless, the development of web-based groupware systems is a time-consuming and costly task because developers either have to become familiar with specific groupware libraries or are asked to re-implement concurrency control services (i.e. document synchronization, conflict resolution). Therefore, we propose a dependency injection mechanism using declarative annotations to incorporate concurrency control services into web applications. Instead of adopting comprehensive libraries or implementing application-specific components, synchronization capabilities are integrated in a lightweight and rapid fashion. To validate the approach, we enriched the widely-adopted Knockout framework with dependency injection facilities and transformed two Knockout-based applications into collaborative ones.

Enriching single-user web applications non-invasively with shared editing support

Collaborative real-time applications like Google Docs allow multiple users to edit the very same document simultaneously which supersedes traditional document merging and document locking techniques. However, developing collaborative web applications is a time-consuming and complex endeavor since it requires implementing document synchronization and conflict resolution services. To accelerate the development of collaborative web applications, we present a rapid transformation approach allowing to non-invasively introduce shared editing capabilities into existing single-user web applications. Instead of changing the applications source code, our non-invasive approach leverages a generic collaboration infrastructure that requires only a configuration to provide document synchronization and conflict resolution services. Hence, the effort to incorporate shared editing capabilities is considerably reduced in contrast to conventional approaches where the use of a programing library entails scattered source code changes. Moreover, we report on the results of a user study demonstrating that converted editors are convenient for collaborative work. We propose a transformation approach allowing to non-invasively incorporate shared editing capabilities in existing single-user web applications.We report on a user study with 30 subjects assessing collaboration qualities in joint work scenarios leveraging two converted editors.We carve out characteristics web applications have to expose in order to adopt the generic transformation approach.

Analyzing the suitability of web applications for a single-user to multi-user transformation

Multi-user web applications like Google Docs or Etherpad are crucial to efficiently support collaborative work (e.g. jointly create texts, graphics, or presentations). Nevertheless, enhancing single-user web applications with multi-user capabilities (i.e. document synchronization and conflict resolution) is a time-consuming and intricate task since traditional approaches adopting concurrency control libraries (e.g. Apache Wave) require numerous scattered source code changes. Therefore, we devised the Generic Collaboration Infrastructure (GCI) [8] that is capable of converting single-user web applications non-invasively into collaborative ones, i.e. no source code changes are required. In this paper, we present a catalog of vital application properties that allows determining if a web application is suitable for a GCI transformation. On the basis of the introduced catalog, we analyze 12 single-user web applications and show that 6 are eligible for a GCI transformation. Moreover, we demonstrate (1) the transformation of one qualified application, namely, the prominent text editor TinyMCE, and (2) showcase the resulting multi-user capabilities. Both demo parts are illustrated in a dedicated screencast that is available at http://vsr.informatik.tu-chemnitz.de/demo/TinyMCE/.

Integrated service engineering workbench: service engineering for digital ecosystems

The evolution of service-oriented architectures towards digital ecosystems comprehends a number of challenges. According to Papazoglou et al., one challenge is to develop services in a dynamic environment with high uncertainties, and in collaboration with other companies. The Integrated Service Engineering (ISE) Workbench is a step in this direction in that it supports a model-driven approach and different stakeholders. This paper briefly introduces the ISE Framework, presents the ISE Workbench and its functionality, and proposes a demonstration of a conducted case study in the IT outsourcing domain.