The Web Services group headed by Athman Bouguettaya
at the CSIRO ICT Centre (Information Engineering Laboratory) has a number
of open projects for students in the area of Service-Oriented Computing (SOC) [1]. The SOC paradigm uses software services
to support the development of low-cost and interoperable distributed applications. Services are
autonomous, platform-independent software entities that can be described, published and discovered.
Services differ in their granularity, ranging from simple services (e.g., for querying weather
information) to complex coarse-grained business functionality (like CRM systems). In the context
of SOC, there is a predominant architectural style commonly referred to as Service-Oriented
Architecture (SOA). It consists of a service provider who creates services and publishes them
in a service registry. A service consumer can then look up services in the registry and dynamically
bind to those services and invoke them. This allows a loose coupling between the provider and the
consumer. These three assets are often referred to as the SOA triangle.
The Web services stack (WSDL, SOAP, UDDI, etc) is probably the most common set of technologies for
implementing SOAs within the SOC space. A good introduction and overview of SOC can be found in [2].
So much for the theory, in practice however, things do not always work as dynamic and agile as
envisioned, e.g., dynamically find and invoke a service [4], managing services [5].
Therefore, we do some research in this area ;).
My particular research interest focuses on service composition, an important area of research
within the field of SOC [3]. In general, simple Web services are often not sufficient to implement
complex business logic. Such an implementation may require the invocation of several other Web
services to achieve this task. Combining the functionality of several Web services creates a new
composite service. The process of developing it is generally referred to as
service composition. Composition can be achieve in different ways, manually, semi-automated,
fully-automated by leveraging semantic descriptions of service, etc. A lot of exciting research is
going on in this area, so come and join us :).
[1] Papazoglou, M.P., Traverso, P., Dustdar, S., Leymann, F. (2007). Service-Oriented Computing: State of the Art and Research Challenges, IEEE Computer, November 2007, p 64 - 71.
[2] Dustdar, S., Papazoglou, M. (2008). Services and Service Composition - An Introduction. it - Information Technology, April 2008, (c) Oldenbourg Wissenschaftsverlag
[3] Dustdar, S., Schreiner W. (2005). A Survey on Web services Composition. International Journal of Web and Grid Services, 1(1), 1 - 30, 2005.
[4] Michlmayr, A., Rosenberg, F., Platzer, C., Treiber, M., Dustdar, S. (2007). Towards Recovering the Broken SOA Triangle - A Software Engineering Perspective. Proceedings of the 2nd International Workshop on Service Oriented Software Engineering (IW-SOSE'07), co-located with the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE'07), 03-07. September 2007, Dubrovnik, Croatia.
[5] Yu, Q., Liu X., Bouguettaya, A., and Medjahed, B. (2008). Deploying and managing Web services: issues, solutions, and directions. VLDB Journal, Volume 17, Number 3, May 2008
If you are interested in any of these projects, please email or call
Florian Rosenberg.
Contact information can be found on my Web page. Please also feel free to propose a project if you have
any great ideas that fit well into our area. All projects can either be carried out during a
summer internship, as honours project or as part of any other project course (depending on that, the
scope of the project varies a bit).
A Domain-Specific Language (DSL) for QoS-Aware Service Composition |
| Description: |
Web services available on the Internet or within companies (e.g., by using WSDL and
SOAP) gain increasing interested as independent software assets that can be invoked over
the network in a loosely coupled manner. In this regard, Quality of Service (QoS) is an
important means to determine the quality of these services. QoS attributes include, amongst others, response
time, throughput, reputation or security.
When composing available services into new and higher level services or processes, QoS
plays an important role. A composition designer may want to express QoS requirements or
constraints on the overall composition, individual parts of a composition or certain
services (e.g., the overall response time should be less than 5 sec and the payment
service needs to support at least X.509 security).
Therefore, a domain specific language (DSL) and editor should be developed to enable the
specification of such QoS-aware composition [1,2]. It should be based on the Eclipse platform to
facilitate efficient and effective development of composition by allowing the programmer
to focus on composition and QoS aspects. The feasibility of the language should be
evaluated by conducting a controlled experiment with a selected number of users.
|
| Research Area: |
Service-Oriented Computing, Programming Languages |
| Technologies: |
Java, Eclipse, Xtext, Web service technologies, etc. |
Prerequisites: |
Good Java programming skills are essential. |
| References: |
[1] Rosenberg, F., Celikovic, P., Michlmayr, A., Leitner, P., Dustdar, S. (2009). An End-to-End Approach for QoS-Aware Service Composition. In: Proceedings of the 13th IEEE International Enterprise Distributed Object Computing Conference (EDOC'09).
[2] Rosenberg, F., Leitner, P., Michlmayr, A., Celikovic, P., Dustdar, S. (2009). Towards Composition as a Service - A Quality of Service Driven Approach. In: Proceedings of the First IEEE Workshop on Information and Software as Service (WISS'09), co-located with the 25th International Conference on Data Engineering (ICDE'09).
|
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |
Automatic Generation of Multi-Step Web Forms for Simple and Composite Services |
| Description: |
Web applications are increasingly replacing desktop applications in enterprise environments.
However, Web application code is ofter badly designed and implemented by mixing presentation
logic with business logic. The MVC pattern tries to address this problem and many frameworks
successfully implement this model (e.g., Ruby on Rails, Grails just to name a few).
In enterprise environments, SOA is becoming a predominant approach to manage the
complexity by separating the business logic into certain pieces, so called services.
Unfortunately, these services often need input from users, therefore, requiring the
creation of Web applications through a series of forms to capture the data and send it to
these backend services. This is a tedious task that can be partially automated by creating
these (often multi step) Web forms automatically.
To do so, it is necessary to know a few details of how the Web service (or multiple Web
services in case of a composition) works internally,
what data it requires and what data is optional, and how the data should be represented and
gathered in the resulting Web form. Additionally, validation and state handling in the
Web forms are important to avoid problem when invoking the service.
In this work, a simple language or annotation mechanism should be developed that allows
to add this kind of semantics to RESTful or Web services. Based on the annotations and the
service description(s) itself, Ajax-based Web form(s) should be generated that can then be
used as the front-end to those services.
|
| Research Area: |
Service-Oriented Computing, Web programming, Web 2.0 |
| Technologies: |
Java or scripting languages,
Ajax, DSLs, Eclipse, Web service technologies, etc. |
Prerequisites: |
Good programming skills are essential. |
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |
A Simulation Environment for a Service Delivery Platform |
| Description: |
Service-oriented architectures are frequently used as a paradigm to implement large-scale
software systems. In these systems, both software services and humans plays an important
role. Different functionality is offered by software services, other services and humans
consume these services. A popular example are human service delivery systems as provided
by different government agencies to deliver a broad service portfolio to their
citizens (e.g., income support, medical benefits, etc).
One of the main challenges for such systems is the fact that service portfolios are
constantly changing and evolving. Therefore, these IT systems need to cope with those
changes in a flexible and adaptive way. To test and experiment with such a platform, it is
crucial to provide an environment to simulate human users and software services including their
behavior in various settings. This allows to evaluate and tune the
service delivery platform and
draw conclusions for an effective configuration of the system. Different technologies
for implementing such a simulation environment should be studied and a prototype should
be implemented (e.g. agent-oriented environments such as
Repast where agents simulate human and system behavior).
|
| Research Area: |
Service-Oriented Computing, Agent-Oriented Technologies |
| Technologies: |
Java or scripting languages, Eclipse, Agent-Oriented Toolkits, etc |
Prerequisites: |
Good programming skills are essential. |
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |
Personalized Service Composition and Adaptation |
| Description: |
Service compositions are often designed in way that they cover one specific use case (i.e.,
processing an insurance claim).
Especially in human-centric processes (i.e., found in human service delivery organizations),
such composite services are often used to implement a specific process. However, in most
cases these processes are not static because they highly depend on the user (or customers)
situation (i.e., his context). Therefore, such composition needs to be adapted at runtime
to provision a personalized composite service that is specifically targeted to the
user’s needs and requirements.
In this project, we try to investigate how such
a personalization of service compositions can be achieved and what runtime mechanisms are
necessary. Specific concepts should be implemented and evaluated.
|
| Research Area: |
Service-Oriented Computing, Web programming, Web 2.0 |
| Technologies: |
Java or scripting languages,
Eclipse, Web service technologies, etc. |
Prerequisites: |
Good programming skills are essential. |
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |
A Universal Benchmark Toolkit for QoS-Aware Service Composition Algorithms |
| Description: |
Researchers in service composition often develop new methods and algorithms to efficiently
build QoS-aware compositions. Common techniques range from automated approaches,
semi-automated approach to manual approaches to build a composition. To evaluate the algorithms
and their performance, researchers
mostly develop a small set of examples, quite often only for
evaluation purposes (without reusing it later on). The goal of this project is to build a
repository of services descriptions, QoS descriptions, and composition templates to allow
other researchers to use it as a basis for their performance tests. Ultimately, this will
allow a comparison of algorithms across different composition approaches and can have a large
impact to the research community. Good starting points can be found in [1,2].
|
| Research Area: |
Service-Oriented Computing, Web programming, Web 2.0 |
| Technologies: |
Java or scripting languages, Eclipse, Web service technologies, etc. |
Prerequisites: |
Good programming skills are essential. |
| References: |
[1] Web Service Challenge
[2] Semantic Web Service Challenge
|
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |
(Semi-)Automated Service Composition Techniques and Algorithms |
| Description: |
Services can be composed using different methods and techniques, such as manual composition,
semi-automated composition or fully automated composition. When using manual composition
techniques, the programmer (or composer if you wish ;)) has to manually describe the
control flow of the composition, i.e., what services are invoked in which order, etc. Based
on that, the programmer selects the corresponding service that need to be invoked and does
all the plumbing to make it deployable. All
these tasks require a lot of effort, therefore we focuses on semi-automated or
automated composition techniques. There was some progress in the past, but it is a long way to go (see
[1] for a good survey of techniques; [2] for a detail tutorial; [3] for an integrated approach).
A higher degree of automation in the composition process requires semantic descriptions of the services that need
to be composed. The ultimate goal is that the end-user just needs to express his/her goals
and preferences what needs to be composed (by using some formalism or domain specific language). Then, the runtime iteratively helps the
developer to create the composition. In this work, we look a novel methods and algorithms
to achieve semi-automated composition by using an iterative approach. This should be
achieved by integrating the developer into the composition process to guide the composition
process and make decision where the runtime cannot fully automate this process. The composition
environment should be provided as an Eclipse plugin (or alternatively as a Web application).
|
| Research Area: |
Service-Oriented Computing, Web programming, Web 2.0 |
| Technologies: |
Java or scripting languages,
Eclipse, Web service technologies, etc. |
Prerequisites: |
Good programming skills are essential. Web service knowledge is a plus |
| References: |
[1] Rao, J., Su, X. (2005). A Survey of Automated Web Service Composition Methods.
[2] De Giacomo, G., Mecella, M. (2006). Automatic Web Service Composition. Tutorial at ICWS'06, Chicago, USA.
[3] Kuester, U., Koenig-Ries, B., Stern, M., Klein, M. (2007). DIANE - An Integrated Approach to Automated Service Discovery, Matchmaking and Composition. In Proceedings of WWW'07.
|
Advisor: |
Dr. Florian Rosenberg (CSIRO ICT Centre) |