Motivation and Background
Service-Oriented Architectures (SOA) promise to break former monolithic applications into loosely coupled services that can be distributed across several systems. These services are composed to implement business applications and processes. Even though service composition is well-understood and covered by existing approaches for technical developers using languages such as BPEL, tools and methodologies for enabling end-user service composition have been largely ignored [1]. A promising approach for bridging this gap are mashups that focus on a user-centric and lightweight UI integration [2] by combining the philosophy of SOA and approaches of End-User Development [3]. The need for such situational applications to address individual and heterogeneous needs as well as the shift to more exible and dynamic business environments encourage the idea of integrating mashup concepts into the enterprise. Our approach shows a way of overcoming limitations of existing mashup approaches [4] in order to build complex interactive service-based applications. Following our preliminary investigations and description of related work [5], this paper discusses the following contributions:
We propose the usage of UI related service annotations to ease service integration and composition. This limits the eort for the development of service-based applications to a purely model-driven, visual composition of annotated services that can even be done by end-users. Although existing approaches, such as Dynvoker [6], already cover the generation of user interfaces for single web services dynamically, no solution is available for service composition.
We adopt the idea of integration at the presentation layer [7] to compose services by combining their presentation front-ends, rather then their application logic or data [2]. Typically, web services are integrated into the application layer of a composite application via their well-dened service interfaces. The service annotations add the missing information about the UI of a single service to lift the integration to the presentation layer.
We propose a tool environment that allows the creation of interactive servicebased applications to nonprogrammers. Most of the existing lightweight composition approaches (overview provided by [8]) support the user only in building complex data representations in form of widgets or feeds, but lack sophisticated concepts following the idea of process mashups [9]. We propose a automatic Model-driven generation approach for the designed interactive service-based applications. The models used within the approach can be applied for representing applications for various target platforms and dierent sorts of application partitioning.
This section presents our idea of composing services in a visual manner to ease and speed up the development of interactive applications that goes beyond existing visual mashup solutions. These applications combine concepts like multi-page support, dynamic UI behavior (e.g. input suggestion functionality, client-side input validation). Therefore, we introduce the concept of UI related service annotations. These are reusable information fragments attached to the service description, which are typically not available for the application developer. They cover static UI aspects, the behavior of UI elements, and relations between services.
Annotations facilitate e.g. the grouping and ordering of UI elements, completion of forms, continuous eld updates, or data conversion (more examples in [5]). UI development is usually a very time consuming task and cannot be done by the targeted end-user group. A trained application developer has to build the UI and integrate the services manually. The developer has to understand the oered interface to integrate the service in an application. This is not necessary anymore, since the integration at the presentation layer is done on a much higher level of abstraction. The user (in the role of the service composer) only works with the presentation front-end of a service instead of an abstract representation in form of a predened service widget. Therefore, UI fragments are automatically generated for the interaction with the services and represent the interfaces for service input and expected output. The fragments can be inferred from technical details such as the data types of parameters, and be further improved by leveraging the annotations attached to the service. UI fragments consist of freely arrangeable UI elements like input elds or buttons. A manual implementation of a service wrapper, as usually required in existing visual mashup environments, is not needed anymore.
Our approach facilitates the development of interactive single-and multipage applications. A page acts as a container for UI elements and represents a screen in the nal application. The integration of services (as described above) and the actual service composition can be done for each page separately. The service composer can dene data ows between the integrated service operations on a single page (intra-page ow) and between pages (inter-page ow). These data ows can be partially derived from service dependencies dened in the annotations or modeled manually by the service composer in a visual way. Different approaches to support this specic task are currently under investigation. One solution could be the selection of a specic output eld of service operation A and drawing a line to the input eld of the service operation B. Another way could be that each generated UI fragment oers all of its outputs and the user can select the associated service operation via a context menu or wizard. To transport the idea of multi-page applications to nonprogrammers we use a metaphor which most of the people are familiar with -Microsoft PowerPoint. Each page (or screen) in the nal application will be presented like a slide in PowerPoint. Furthermore, it is possible to dene a master layout that all pages will use. To build multi-page applications, the pages can be linked to each other by specifying a navigation path. 3 End-User Centric Tool Support
Our visual composition editor which implements the concepts introduced in Sec.
2 is currently under development in the frame of the EU funded project ServFace [10]. The main focus of the composition editor is the empowerment of end-users to develop interactive applications. Multiple design decisions were made based on this requirement. The tool is designed as a rich internet application (RIA) which runs in the web browser of the user and makes an installation dispensable. The annotations facilitate the understanding and simplify the composition of web services. Finally, the visual composition concepts guide the user through the development process by providing intuitive metaphors and hide the complexity of the actual programming task. Our user-centric implementation approach involves iterative evaluations with end-users. The composition editor is integrated into a three step methodology for the development of interactive applications as explained in [11]. The annotations are created by an IT expert and stored in an annotation model based on a formally dened Meta-model. The visual service composition tool imports in a rst step the functional interface descriptions of the web services and their attached annotation models. The result is a platform-specic object model structure kept in the tool representing the complete designed application.
Figure 1 shows a mockup of the envisioned composition editor. The user can import annotated services that shall be used in the application. These services ComposableWeb'09 are displayed with their operations in the Service Operations palette. The user can drag service operations from the palette to the composition area. The editor displays the UI fragment inferred from the operation interface and the service annotations. The user can rene the layout, delete unwanted UI widgets or add additional ones from the Widgets palette, and dene intra-page data ows. Besides this basic mashup editor functionality our composition editor pro- After nishing the application development, the mentioned object structure is serialized to a model coined Composite Application Model (CAM). Its underlying Meta-model is reused for representing applications for various platforms. A serialized CAM is used as storage format for the composition tool and as input for generating executable application as described in the next section. 4 Generating Applications
In regards of bringing the composed interactive application to execution, the decision has been made to use a code generation mechanism. In comparison to deploying the design-time outcome on a specic interpreter, code generation promises a higher eciency. The chosen approach is realized in a model-driven manner. In order to bring the instance of the CAM Meta-model closer to the executable application and to resolve the annotations that are explicitly represented within the CAM to runtime information, a Model-to-Model transformation is applied in a rst step. As it is the case for the CAM, the target Meta-model (named PROSAIC) can be reused for representing applications for a variety of platforms.
A major challenge in realizing this approach has been to dene a reference architecture for service-based interactive applications reected in this Meta-model that can be used as an abstraction from concrete platforms and frameworks. Figure 2 shows an example of the control and data ow within the reference ar-Fig. 2. UI-to Service-interaction within the reference architecture chitecture developed for our approach. To support single page applications (e.g. RIAs) as well as multi-page applications, a dierentiation between a page ow controller and a behavior controller has been introduced. Both controllers are located within the Model-Control-Adapter (MCA). Its major task is to coordinate the interaction between the user interface and the service infrastructure. The page ow controller contains a set of states and transitions between states. On state activation the state registers a set of commands within the behavior controller. These commands are mapped to a set of activities where an activity can contain actions such as the invocation of a service or assigning values to global variables. The commands are used for realizing the behavior of the user interface of the page associated with the state. For example if a widget displaying stock information should be updated in regular intervals, it triggers a command in a loop and sends it to the MCA (e.g. via Ajax functionalities). The MCA calls the service that returns the stock data and sends a reply to the UI that includes the new stock values into the widget. This proposed reference architecture is reected within the PROSAIC Metamodel. During several tests it has been evaluated that instances of this Metamodel can be transformed via Model-to-Model and Model-to-Code transformation to several platform and framework specic source code. Besides transforming it to Web applications (Dojo toolkit and the Spring framework) it has been proven that it can be applied for generating fat clients e.g. for mobile devices (Google Android applications).
The generation of the resulting application is done completely automatically by using an automatic build script for Ant that is triggered by the composition editor and that starts the M2M transformation implemented in ATL and the M2C transformation implemented by using openArchitectureWare. Furthermore this script enables the packaging and deployment of web applications.
Yet an open issue is the formal denition of the relations between the service annotations kept explicitly within the CAM and the PROSAIC Meta-model. This formal denition promises a starting point for a simplication of the template creation for the M2M transformation. The concept of presentation integration can be seen as the next major step in the integration area [7]. Our paper presented an approach to lift the service composition to the level of presentation integration via UI related service annotations. The presented visual composition concepts as well as the associated tool will empower nonprogrammers to create composite applications, which suit their requirements and individual needs. The active involvement of the actual service consumer in the integration and composition process can result in a more sucient usage of knowledge, specic for their domain, and raise their productivity.