Towards End User Service Composition by xqg16657

VIEWS: 12 PAGES: 3

									                               Towards End User Service Composition
                               Xuanzhe Liu, Gang Huang, Hong Mei
School of Electronics Engineering and Computer Science, Peking University, Beijing, China, 100871
                        liuxzh@sei.pku.edu.cn, huanggang@sei.pku.edu.cn , mieh@pku.edu.cn

                       Abstract                              technologies are too many professional to the end users to
    The popularity of Service Oriented Computing (SOC)       rapidly and simply grasp and apply.
brings a large number of distributed, well-encapsulated          However, in the internet environment, the number of
and reusable services all over internet, and makes it        end users is much larger than that of professional users.
possible to create value-added services by means of          For example, in USA, there had been 90,000,000 end
service composition. Current composition styles are too      users, while only 3,000,000 professional ones [1]. It is
professional to those end users when building their own      unreasonable and impossible for the end users to grasp
applications. Actually, the end user would prefer rapidly    professional composition technologies. Therefore, the
discovering “best-of-breed” services to assemble as well     popularity of service composition will be heavily limited
as visually personalizing the presentation to enjoy rich     if no consideration from the end user perspective.
experiences. In our work, we propose a composition                The end user composition involves some grant
approach to facilitate service composition in a fast and     challenges. First of all, as there are so many providers
simple manner. We try to solve composition difficulties      offering services with similar functionalities, current
from the end user perspective: on demand service             search-based discovery will consequentially return a
selection, automated QoS negotiation and visualized          number of candidates and cost end users much time and
service composition. In our approach, similar candidate      effort. Secondly, their desired QoS should be guaranteed,
services are aggregated together as a unified resource,      so there should be efficient and powerful QoS negotiation
whose wide QoS spectrum can be easily manipulated by         according to the requirements. Finally, the end users
the end users to satisfy their requirements. Then they can   would rather personalize the composite service
personalize the services and, the composition occurs only    application, and usually prefers the visualized
at the presentation layer.                                   customization in “what-you-see-is-what-you-get” manner
    The main contributions of the approach                   [8].
are:(i)enabling the end users to personalize the composite
application with more powerful presentation; (ii)            2. Approach Overview
supporting the end users to dynamically customize the            We have made some efforts in terms of end user
service composition in terms of QoS;(iii) alleviating the    service composition and proposed an approach to solve
end users from the time-consuming task of selecting          the grand challenges above. The core principle is to
service to compose.                                          facilitate the end users to freely, rapidly and simply build
                                                             their own applications according to their preferences. To
1. Motivation                                                alleviate the time-consuming discovery, we aggregate
   Service Oriented Computing has been a hot research        similar services as a unified resource view to end users.
topic in both academia and industry. Services are self-      The wide QoS spectrum such aggregation brings also
describing and platform-agnostic computational elements.     enables the end users flexibly enough to control QoS
The “loosely-coupled” feature guarantees flexibility. With   negotiation. The localized composition environment
the proliferation of service resources, the composition of   makes personalization visually and rapidly.
value-added applications will bring more benefits to the         Figure 1illustrates the framework for the approach. We
large amount of consumers over internet. There are some      briefly introduce the approach from the following
famous composition technologies, such as BPEL and            perspectives.
WS-CDL, which have been widely applied to assemble
existing services.                                               2.1 Service Aggregation
   Though these composition solutions are powerful, we          Service composition begins from the selecting proper
realize some a fact: they are extremely suitable to          component services. As discussed before, there must be a
enterprise users instead of regular end users. The reason    lot of providers offering a specific functionality, e.g.,
is, these technologies involve relatively strong             Google and Yahoo! have already developed map services
requirements overhead about user’s professional skills,      for location. Such proliferation derives from the open,
e.g. XML and BPEL, development environment, e.g.             flexible services and the market competition. The
design-time IDE tools, and runtime middleware (SCA           proliferation of provides really increases the options to
server or BPEL engine). In other words, these                end users. However, current discovery mechanism, e.g.,
                                                             keyword searching and category browsing, will return a
number of candidates. Therefore, the selection may be              We have analyzed the obstacle for end users to use
very time-consuming.                                            current professional composition technologies. Therefore,
                                                                it is necessary to provide an end user oriented
                                                                composition environment which makes them feel like
                                                                using desktop applications. Such environment should
                                                                provide features including:
                                                                     High usability and personality: end users would
                                                                     rather visually interact with a set of rich UI instead
                                                                     of reading textual interface specifications. The
                                                                     powerful user experience is the key to the high level
                                                                     of usability [7]. On the other hand, the end users
                                                                     prefer personalizing the composition according to
                                                                     their own preferences.
                                                                     Low latency: another defect of current composition
                                                                     is the response-time latency from the underlying
                                                                     heavy weight infrastructure. The end users would
                                                                     expect fast response-time from the applications. It
                                                                     implies the use of asynchronous mechanism to
                                                                     perform UI operations while invoking service in the
              Figure 1 Approach Overview                             backend. Additionally, the UI should update
                                                                     incrementally instead of frequent page refresh.
   From our point of view, it is unnecessary and                     Consistent look and feel: the composite service
unreasonable that end users face so many providers. In               should use the same UI metaphors and conventions
fact, these services are very similar or even the same               as desktop applications, to reduce the end users’
functionality while different in QoS. Therefore, if the              learning curve [8].
services can be represented in a simple way, and their             Considering the requirements, we have designed a
QoS can also be negotiated by the users, the selection          runtime composition model and employed the concept of
would be much easier.                                           mashup [10], from web 2.0, to support a web-based
   In our work[1][2][4], we have designed a mechanism           composition engine. The model consists of three elements:
to aggregate the similar providers as a unified resource             UI Component: it is the entity which interacts with
view, named service pool. The service pool construction              end users in the engine. Generally, the UI
is based on the similarity retrieval. We carefully studied           component is based on current popular presentation
current service description style, e.g., WSDL, and                   technologies, such as HTML widgets including
formalized the meta-information. Based on current                    button, text input and form. A UI component
search-based discovery, an agent retrieves the candidates’           provides a set of operation to the end users and
similarity in terms of service name, operation and                   invokes the backend service by events. It should be
input/output. Besides, the agent also measures the domain            noted that a UI component can be flexibly tied to a
similarity in a tree-based manner. After this filtering step,        service.
the precision of services aggregated can reach over 90%              Service Component: it is the implementation of
[2]. Then a virtual service description is generated to              service, both local and remote. In our approach, a
represent service pool as a single and unified resource.             service component can be a service pool or any
   Another effect service pool brings is the QoS spectrum            other services with clear interface specification.
of aggregated service. Obviously, service pool promises              Connector: it is a set of configuration information
much wider QoS range for users to enjoy. We designed a               between UI component and service component.
dynamic QoS negotiation mechanism so that end users                  Once the end users invoke a UI component
can on demand attain desired QoS by manipulating                     operation, the engine will raise an event to interpret
service pool.                                                        the configuration including service URL,
                                                                     namingspace and parameter/operation mapping.
    2. 2 Service Composition                                       In terms of executing composite service, the service
   Service pool is transparent to end users as a backend        composition engine takes charge of registering the UI
discovery/negotiation engine. It means the end users only       component and managing the interactions between them.
face a single provider and adjust their QoS requirements.       As the service components usually reside on the remote
Therefore service pool becomes the component service to         server, the engine employs the popular AJAX
compose.                                                        (Asynchronous JavaScript + XML). A large portion of UI
                                                                component code is in client-side JavaScript, which makes
asynchronous network calls to service component via            4. Conclusion and Future Work
XML messages and then modifies client-side UI through             End users service composition is a big opportunity
HTML DOM. This mechanism improves user                         with the popularity of SOC as well as grant challenges.
interactivity, since the JavaScript code is able to modify     The main contributions of our work are:(i) enabling the
client-side HTML without reloading the entire page. In         end users to personalize the composite application with
addition, since the XML messages may be sent                   more powerful presentation; (ii) supporting the end users
asynchronously, users are not blocked from further             to dynamically customize the service composition in
interactions. Therefore, the composition task end users        terms of QoS;(iii) alleviating the end users from the time-
become easy and lively.                                        consuming task of selecting service to compose.
    The service execution is incarnated by the service pool.      The future work includes: enforcing the fault-tolerance
As service pool only provides virtual operations and           and security for end user composition and the optimizing
input/output, the messaged raised in the client-side should    the dynamic QoS negotiation.
be routed to the service satisfying end users’ QoS.            5. References
Therefore necessary mappings are required. In the service      [1]. Xuanzhe Liu, Gang Huang, Hong Mei. Towards Service
pool side, we employ the reflection [5] and dynamic                  Discovery and Subscription based on Community-of-
compiling to generate proxy for the service. It should be            Interest. Accepted by Second International Symposium on
noted that the increasing concurrent end users and                   Service Oriented System Engineering (SOSE 2006),
message size may cause performance overhead for                      pp149-156.Shanghai, China, 24-26,October, 2006.
service pool, we have also provide efficient mechanisms        [2]. Xuanzhe Liu, Li Zhou, Gang Huang, Hong Mei. Service
including for such problem [3]. As the UI component is a             Pool Based Service Discovery and Subscription. The 16th
set of Javascript code at runtime, invocation results from           ACM International Conference on Web Wide Web,
                                                                     (WWW 2007). Banff, Canada, accepted to appear.
service pool are processed by a data wrapper to restrict
                                                               [3]. Xuanzhe Liu, Gang Huang, Hong Mei. A Consumer-
them in a standard format (we employ the JSON [11]).                 Centric Service Aggregation: Method and Supporting
    So far the end users then can visually compose the               Framework. Submitted to Journal of Software
services (to them is UI component only) by simple “drag-       [4]. Gang HUANG, Li ZHOU, Xuanzhe LIU, Hong MEI,
and-drop” action and the presentation is updated with                Shing-chi Cheung. Performance Aware Service Pool in
very low latency. They can also make modifications of UI             Dependable Service Oriented Architecture. Conditionally
component to customize and personalize the presentation.             accepted, Journal of Computer Science and Technology.
                                                               [5]. Gang HUANG, Xuanzhe LIU, Hong MEI. SOAR:
                                                                     Towards Dependable Service-Oriented Architecture via
3. Demonstration                                                     Reflective Middleware, Accepted for publication,
                                                                     International Journal of Simulation and Process Modeling.
   We have designed a set of tool for end users to fast        [6]. Scaffidi, C., Shaw, M., and Myers, B. “Estimating the
create UI component and configure it with service                    Numbers of End Users and End User Programmers,” in
component. Figure 2 shows the eclipse-based composition              IEEE Symposium on Visual Languages and Human-
interface. The bottom part is the web-based mashup view.             CentricComputing (VL/HCC'05). 20-24 September, 2005.
                                                                     Dallas, Texas: pp. 207-214.
The end users can tie a UI component with a service pool
                                                               [7]. Jin Yu, Boualem Benatallah, Regis Saint-Paul, Fabio
by simply adding some configuration information. Once                Casatio, Florian Daniel, Maristella Matera. A Framework
services are composed, the architecture view shows the               for Rapid Integration of Presentation Components. The
whole architecture of the application. The end users can             16th ACM International World Wide Web Conference
do modification at any moment and synchronization is                 (WWW2007). Banff, Canada. Accepted to appear.
just-in-time between the two layers.                           [8]. Florian Daniel, Jin Yu, Boualem Benatallah, Fabio Casati,
                                                                     Maristella Matera, Regis Saint-Paul. Understanding UI
                                                                     Integration: A survey of problems, technologies, and
                                                                     opportunities. IEEE Internet Computing. IEEE. 2007. ( To
                                                                     Appear )
                                                               [9]. Xin Dong, Alon Halevy, Jayant Madhavan, Ema Nemes,
                                                                     Jun Zhang. Similarity Search for Web Services.
                                                                     Proceedings of the 30th Very Large DataBase (VLDB)
                                                                     conference, Toronto, Canada, 2004.
                                                               [10]. Duane Merrill. Mashups: The new breed of Web app--An
                                                                     introduction        to        mashups.        http://www-
                                                                     128.ibm.com/developerworks/xml/library/x-mashups.html
                                                               [11]. JSON: http://www.json.org/


              Figure 2 Tool Demonstration

								
To top