FKZ 01IS08034-C

Outline

Trends
Problems
Goals

Motivation and Goals

Current Trends

In the recent years the Internet has evolved from a medium of pure information presentation to a medium for communication and interaction. Due to the inherent advantages, like instant availability anywhere at any time, improved reliabililty, performance and scalability (due to distribution), almost all software vendors have moved their services to the Web....

In parallel to these technical trends, the IT world is changing fundamentally due to an "impossible equation" [Bezivin, 2011]: a slowly growing number of software developers is facing a dramatically growing need for individualized application solutions, which can not be covered with existing development and deployment models. To his end, a role change between IT and operating departments, i.e., between developers and users is taking place. Developers provide generic platforms and components, which empower users and domain experts to solve their specific tasks on their own, by "mashing up" their individual solutions from well-designed and tested building parts. This idea is dubbed End User Development (EUD).

These trends are fostered by the so-called Programmable Web, i.e., the internet of services. It facilitates the distributed development and deployment of data, business logic and complete applications, which can be bound and combined using generic, platform-independent interfaces.
The paradigm of Mashups employs these principles. It strives for a "light-weight" combination of these distributed web resources, i.e., of contents and functionalities, to build more complex applications. In contrast to traditional software development, the mashup life cycle is much shorter, as its focus lies on the rapid and cheap creation of situative applications from ready-made building blocks (services).

The composition of interactive mashup applications can, however, not yet easily be achieved by non-programmers. Besides the technological complexity - especially at the presentation layer - the heterogeneous user, usage, and device contexts pose additional requirements (Which services is currently available and useful?, Which data visualization makes sense for a goal, user and device?), which are not yet covered in models and platforms. This results in dedicated throw-away and recreate UIs developed manually by IT professionals for specific application contexts [Davies, 2006], which is both cost- and time-intensive.

In this regard, mashup research has come up with the idea of Presentation Integration. Its principle is to support service and application integration at the presentation layer. Composition objects are not longer web services, but web apps, portlets, or widgets. By visually composing the mashup UI, end users actually compose the whole application. Naturally, concepts from the SOA domain can only be applied partly, since they are not indended for interactive components. With the previous requirements in mind, existing presentation integration concepts have an essiential disadvantage, though: Data, business logic, and UI are tightly coupled in the building blocks, which results in inflexible solutions that cannot be easily contextualized. For instance, it is not possible to easily change a service "behind" the UI.

Go to top...

Problems

The ideals of mashups and the reality of modern SaaS solutions are worlds apart: While well-established models for the development of conventional desktop software and adaptive hypermedia applications exist, the structured development of interactive composite web applications (mashups) is still in its infancy. The underlying SOA concepts have simplified the integration at the data and business logic layers, but they neglect user interfaces and interaction...

These trends lead to the following research problems the CRUISe project addresses:

So far, mashup applications are developed programmatically, as distribution and composition are only supported for services in the backend. Consequently, the creation and maintenance of the UIs and their binding to the backend are very complex and costly.
Mashup UIs are usually bound to concrete technologies and platforms. This hinders interoperability and reusability, so UIs are recreated for different platform and application requirements.
The growing heterogeneity of user and usage contexts results in an increasing technological complexity, which is not handled yet by existing solutions:
- SOA concepts and standards are limited to process-oriented, automated service compositions without taking user interaction and UIs into consideration.
- Web Engineering approaches have a document-centric view. They model data and their presentation, not the composition of independent, distributed functional building blocks.
- Existing mashup concepts rely on programmatic development or the use of proprietary tools. Further, the missing separation of concerns between UI and backend in presentation integration approaches negatively effects applications' flexibility, maintainability, and quality.
All in all, the high development effort contradicts the goal of quick and light-weight development.
Existing mashup solutions employ stateless building blocks, e.g., web services, which are composed by connecting their inputs and outputs. Neither the state of the UI, e.g., the selection of contents, nor more sophisticated coordination and interaction concepts, such as state synchronization, data pull or drag-and-drop are supported.
Mashups are currently developed as static compositions of specific, distributed resources. The possibilities of the SOC, such as the late binding of services, are not applied. As a result, a context-aware dynamic discovery and integration of mashup parts is not possible.
Prevalent mashup approaches lack adaptation concepts to cope with the dramatically increasing number of devices, usage scenarios and user preferences. In this regard, both concepts for the generic, reusable definition of adaptive behavior and corresponding adaptation archictures are missing:
- Adaptation in SOA does not consider adaptive UIs at all. It is targetted at stateless services, i.e., their context-aware exchange and message manipulation.
- Adaptive Hypermedia solutions are based on a document-centric view of the web and thus employ hypertext concepts (links, pages, etc.). Their adaptation methods and techniques can not be applied to functional compositions, resp. mashups.
- Existing platforms for interactive Mashups do not consider adaptability at all. Conceptually, they are limited to the SOA concepts.

Go to top...

Challenges and Research Goals

To address the problems mentioned above, we envision a model-driven development process for adaptive, component-based web applications, with a special focs on interactive mashups. Thus, in the CRUISe project we face three fundamental research challenges:

Modeling
Creating a platform-independent universal (meta) model for components and their composition to interactive mashups.
Execution
Realizing a modular composition infrastructure for the dynamic composition and execution of the modeled applications.
Adaptation
Supporting context-awareness both in the component discovery and composition process as well as at mashup runtime.

In consideration of these challenges, we strive for the following research goals...

1. Modeling

Central goal of the project is to employ the advantages of service orientation at all layers of interactive web applications, including the user interface. This implies that all application parts are represented universally in a generic way as 'components'. This representation forms the basis for the publication, dynamic binding, and lose coupling of components.

Universal Component Model
An open, universal component model shall be developed, which allows for the uniform representation of reusable application components at the data, business logic and presentation layer. Its abstractions and communication paradigms shall enable the free composition across all application layers. It shall be formalized in a declarative, platform-independent way in the style of the WSDL and allow for the management, discovery, binding and configuration of components.
Platform-Independent Composition Model
A dedicated composition meta model shall enable the platform-independent specification of interactive web applications composed from above-mentioned components. This includes the representation of component configuration, data and control flow, as well as aspects of the user interface, such as the layout. Furthermore, modeling tools for non-programmers are developed.

2. Execution

Besides the development process and the underlying models, the architecture of composite web applictions is a central research point in the project. In this regard, an open and flexible infrastructure is needed for the mashup composition and execution. In contrast to proprietary solutions, the CRUISe project shall provide the necessary abstractions to allow execution on different technological platforms.

Dynamic, Context-Aware Binding
The SOA principles - especially with regard to dynamic binding and lose coupling of services - shall be applied to universal mashup compositions. This implies the definition of an integration process to dynamically search and integrate suitable components based on a composition model and the current context. In this regard, additional concepts for the management of components and context information shall be developed.
Reference Architecture for the Universal Composition
A flexible composition platform shall be developed, which supports a model-driven composition and execution of web applications, including the dynamic integration and lose coupling of above-mentioned components at runtime. As a basis, a modular composition infrastructure shall be developed, which provides all necessary services, e.g., component management and discovery, via generic interfaces to different technical realizations of the reference platform.

3. Adaptation

An orthogonal challenge, which has been neglected so far in mashup research, is the development of corresponding adaptation concepts. Adaptation must be considered by both the models as well as the composition infrastructure and runtime environment.

Formalization of Adaptation Techniques
Existing adaptation methods and techniques for service-oriented and hypermedia applications shall be evaluated and formalized with regard to the needs and possibilities of universal mashup compositions. This includes the creation of dedicated modeling artefacts to express component-specific and cross-component adaptation (patterns) in an abstract and technology-agnostic manner.
Contextualization and Dynamic Adaptation
Finally, the intepretation and realization of the abstract adaptation knowledge shall be realized. This implies the integration of context monitoring and management facilities. Further, adaptation techniques need to be integrated seamlessly with the above-mentioned runtime platform(s).