Spurred by Web 2.0 paradigm, there emerge large numbers of service mashups by composing readily accessible data and services. Mashups usually address solving situational problems and require quick and iterative development lifecyle. In this paper, we propose an approach to composing data driven mashups, based on tag-based semantics. The core principle is deriving semantic annotations from popular tags, and associating them with programmatic inputs and outputs data. Tag-based semantics promise a quick and simple comprehension of data capabilities. Mashup developers including end-users can intuitively search desired services with tags, and combine several services by means of data flows. Our approach takes a planning technique to retrieving the potentially relevant composition opportunities. With our graphical composition user interfaces, developers can iteratively modify, adjust and refine their mashups to be more satisfying.

Services computing paradigm together with Web services have significantly promoted the automation of business process in enterprise. Prevalent service composition technologies, such as WS-BPEL and WSCI, provide promising means to deal with machine-to-machine communication. Traditionally, in the phase of business process modeling, there usually require some human-involved tasks. Recent new technologies such as BPEL4People and Human Task begin to consider involving human interaction in business process. However, such approaches still have some limitations. On one hand, they exactly require some extensions of current BPEL standards. As a result, the existing business processes have to be rewritten and redeployed. On the other hand, they yet lack of the development and deployment supports of flexible and reusable user interfaces in business process. In this paper, we address these issues by enabling human interaction in business process with rich web applications. Our approach models human tasks as services, and can be seamlessly integrated to current BPEL without any modifications to existing engine and processes. We further support building human task presentations from service-oriented rich user interfaces. During the process execution, the corresponding task stakeholders can select, configure and compose these reusable and rich UI components according to their own application context.

The Web is currently moving towards a platform with rich services. A notable trend is that end-users create mashups composing services with short, iterative development life cycles as well as updating with evolving needs. However, the large number of services and the high complexity of composition constraints make manual composition extremely difficult. Addressing this issue, we have developed an approach to assisting the end-users to build mashups in a simple and fast fashion. A tag-based model provides end-users a quick and intuitive insight of services. End-users simply describe their desired goals with tags. Interacting with a service repository, our approach employs a planning approach to suggest services that end-users might want to involve in the final outputs, including some additional interesting or relevant ones to induce more potential composition opportunities. End-users are allowed to iteratively modify, adjust or refine their goals. We have implemented our approach with a tool called iMashup.

Along with the proliferation of web-delivered services and the wide adoption of popular Web technologies, it has been an emerging development style that composes service-oriented applications with rich user experiences in the web browser. Currently, these service-oriented rich client (SoRC) applications are usually tightly coupled with specific requirements and scenarios, without the solutions of common problems for development, deployment and operation. It leads to the fact that SoRC applications are exactly done in an ad-hoc manner. In this paper, we propose a new type of middleware, which is embedded in web browsers and encapsulates reusable solutions for common problems. This browser-embedded middleware consists of a container managing component instances, a set of communication mechanisms coordinating both browser-server and inter-browser interactions. Different SoRC applications can be constructed more easily based on the middleware. In the case study, we construct a mashup environment, called iMashup, with the middleware and compare it with some popular environments. The comparison shows that iMashup provides composition capabilities with less implementation efforts, occupies much lower memory consumption and achieves more scalability.

Since many web sites provide their own services and a web browser becomes a rich client platform, a new type of web application that is constructed by assembling web-delivered services in web browser, called Service-Oriented Rich Client (SoRC), emerges. Typical SoRC applications include web OSes and mashups. Due to the increasing complexity of SoRC, we propose a new type of middleware, which is embedded in web browsers and encapsulates reusable solutions for common problems of SoRC, including a container for component instances, a set of mechanisms for interactions within the browser, between the browser and server. Different SoRC applications can be constructed easily in high quality based on this middleware. We implement a prototype of the Internetware browser middleware, and then build two SoRC applications based on this prototype: 1) a web-based BPEL editor, iServiceStudio; 2) a mashup environment, iMashup.