04-08-2012, 02:48 PM
A Programming Language for Web Service Development
A Programming Language for Web Service Development.pdf (Size: 166.22 KB / Downloads: 51)
Abstract
There is now widespread acceptance of Web services
and service-oriented architectures. But despite the
agreement on key Web services standards there remain
many challenges. Programming environments
based on WSDL support go some way to facilitating
Web service development. However Web services
fundamentally rely on XML and Schema, not on contemporary
programming language type systems such
as those of Java or .NET. Moreover, Web services are
based on a messaging paradigm and hence bring forward
the traditional problems of messaging systems
including concurrency control and message correlation.
It is easy to write simple synchronous Web services
using traditional programming languages; however
more realistic scenarios are surprisingly difficult
to implement. To alleviate these issues we propose a
programming language which directly supports Web
service development. The language leverages XQuery
for native XML processing, supports implicit message
correlation and has high level join calculus-style concurrency
control. We illustrate the features of the
language through a motivating example.
Introduction
With the increasing use of software applications for
the daily conduct of business, the need to link these
applications with minimal effort and in short timeframes
is becoming ever more evident. Concomitant
with the development of this need and greatly
motivated by it, Service-oriented Computing (SoC)
is emerging as a promising paradigm for enabling
the flexible interconnection of autonomously developed
and operated applications within and across
organisational boundaries (Alonso, Casati, Kuno &
Machiraju 2003).
Motivation
SoC brings along a number of specific requirements
over previous paradigms (e.g. object and componentoriented)
which unavoidably need to be taken into
account by any Service-oriented Architecture (SOA):
Explicit boundaries: As services are expected to
be developed by autonomous teams, designing
SOAs is an inherently collaborative process involving
multiple stakeholders from different organisational
units. This raises the issue that certain
organisational units may opt not to reveal
the internal business logic of their services to others,
making it difficult (yet indispensable) to ensure
global consistency.
Language features
The language’s feature set has been designed in response
to the three requirements outlined in Section
2: explicit boundaries, coarse granularity and
process awareness. Explicit boundaries are supported
by encouraging the programmer to work at the service
level of abstraction. The service is the largest unit
of implementation, and only behaviour-less interfaces
are shared between services. We intend this lack of
a small-scale reuse feature, such as objects, to promote
service composition and granular services. Our
concurrency and message correlation features make
it easy to program service interactions by supporting
the process-aware nature of services. Furthermore,
we view XML data and messaging as fundamental to
Web services, and the language includes features for
XML data manipulation.
Conclusion
We have highlighted challenging issues in implementing
Web services and, acknowledging that service development
can not be driven purely by high-level
models, illustrated several novel programming language
features that support the implementation of
Web services. We have argued that these features improve
over previous related proposals in the key areas
of XML data, concurrency and message correlation.
Future directions We are implementing a compiler
for our language design. The compiler currently
only supports a subset of the features outlined here.
The compiler produces binary components that run
on the the .NET CLR. These components can be deployed
as Web services with a minimal host program
written in C#. For low-level Web services protocol
support, the components bind to the Microsoft Web
Services Extensions (WSE) library. The concurrency
feature is implemented in terms of the shared-memory
concurrency primitives of the CLR.