A Flexible System for Visual Service Composition

This dissertation brings together ideas of different research areas. First of all, we propose the application of visual languagesto service composition. In order to connect basic Services of various kinds into a larger system, their interactions along the time dimension are defined with the JOpera Visual Composition Language. As opposed to the textual or XML-based syntax of existing approaches, our language features a very simple graphical notation. This visual syntax is used to specify the data flow and control flow graphs linking the various service invocations. This way, it becomes possible to rapidly build distributed applications out of a set of reusable Services by literally drawing the interactions between them. To achieve this, we present how usabilityfeatures such as automatic, incremental graph layout and visual scalability features such as multiple views have been driving the design of JOpera's visualservice compositionenvironment. To provide supportfor realistic application scenarios, we have also included recursion,iteration and refiection constructs with minimal changes to the syntax of the visual language. Supported by the JOpera system, our visual language for service compositionhas been applied to many scenarios, as documentedby the examples shown throughout the dissertation. Underneath the visual syntax, our approach to modeling service composition is based on the concept of process. In this dissertationwe borrow the notion of business process so that it can be extended to model service oriented architectures. Thus, the structure of a process definesthe partial order of invocation of its Services, the data exchanges between them and the necessary failure handling behavior. In this context, an important contribution of this dissertation is the idea that a com¬ position language should be orthogonal with respect to the types of components that are employed. More precisely, in our approach, composition is defined at the level of service interfaces. Therefore, a process is completelyindependent from the mechanisms and protocols used to access the implementationof its Services. In other words, we introduce a compositionlanguage which is not limited to describing how components of a specific type (e.g., Web Services) shouldbe composed. Instead, in our open componentmeta-model, we generalize the notion of service by abstracting common features among a large set of different component types. This abstraction has several important implications. By supporting a large and open set of types of Services, the composition language is simplified because many constructs (e.g., modeling synchronous or asynchronous serviceinvocation) can be shifted from the compositionlanguage to the componentmeta-model. Also, the service composer is free to choose the most appropriate mechanismto access the functionalityof an ex¬ isting service. Thus, the runtime overhead of a serviceinvocation can be minimized