The aspect of human interaction becomes more and more relevant for service-oriented applications. On one hand, current development approaches support the composition of services but neglect the creation of user interfaces. On the other hand, task-based modeling of user interactions is well established but poorly integrated into service-oriented development. In this paper we propose an integrated modelling approach for the taskdriven development of interactive service-oriented applications. Our central concept is the introduction of annotations as part of the Web service description. These annotations cover information relevant for the semi-automatic generation of task models and user interfaces. We present the annotation concept as well as concepts for the integration of the annotations into a task-driven software development methodology.
Due to the increasing complexity of applications and the large number of user interface (UI) technologies and toolkits that exist today, designing interactive applications is still a challenge for application developers. A promising approach to handle this complexity is task-driven software development , . The concept of task-driven software development is to describe an application based on a task model.
A task model consists of tasks which the user (user tasks), the system (system tasks), or the user and the system (interaction tasks) must perform in order to achieve a particular goal. It also captures the order in which these tasks must be performed. In a fine-grained task model, each system task corresponds to a single function call and each interaction task to a single man-machine dialog. The strength of task modeling is its technology-independence and its ability to capture user interaction and application logic in one model which can eventually be transformed into executable code. In the terminology of model-driven architecture, a task model is a domain-specific language for describing interactive applications.
Three artifacts can be derived from a task model through transformations: a control flow with hooks for dialogs and function calls, an initial version of the application’s UI, and a code skeleton of the application logic . Only the control flow can be transformed into executable code without further modifications. The initial version of the UI lacks layout definitions, usability optimizations and the selection of appropriate UI controls. This information has to be added by the developer in a cumbersome and time-intense UI refinement process. The code skeleton is only a partial implementation of the application logic which must be completed by writing code for algorithms, database queries, etc. In service-oriented applications, this application logic is implemented by service operations. They could provide the implementation of system tasks if task models would be extended towards support for binding service operations to system tasks.
Task-driven software development can furthermore profit from service annotations. Service annotations enrich service descriptions for example written in WSDL  or WADL  with information beyond a purely functional specification. Approaches for generating suitable UIs for web services based on service annotations already exist, for example WSGUI  and Dynvoker .
They implement an inference mechanism to generate a form-based UI from WSDL files and annotations that contain hints to generate layout, UI controls and labels. Since the transformation of interaction tasks into an initial version of the UI is based on a similar inference mechanism, service annotations could substantially increase the quality of the initial UI and reduce the manual effort for the UI refinement. The concept of service annotations is by far not limited to aspects of UI generation. For example, annotations can also be used to check the completeness of task models based on dependencies between service operations.
In the following, we present work-in-progress that aims to extend task-driven software development towards annotated services based on the task model and the model transformations developed in the EMODE project . We first discuss our concepts for service annotations. Afterwards, we show how service annotations can be exploited in task modelling and UI generation. The paper concludes with a summary and an outlook on future work.