topical media & game development
research direction(s) -- service oriented computing
Currently, one of the leading open source game engines is
Delta3D,
which consists of a collection of (open source) software components,
well-maintained by a team at the Naval Postgraduate School in Monterey (CA).
This section, which was previously called
open source game development,
will look at the way existing game engines may be enhanced by using services,
for example web services that may be invoked by a REST-protocol (using urls),
SOAP (Sinple Object Access protocol) or XML-RPC.
In [AMICOCALC], we present the following scenarion, or problem statement:
scenario(s)
Michelle is a writer, and she writes a book about Dutch paintings.
To collect necessary information, she analyses different sources about Dutch culture,
many of them in Dutch language. However, being a beginner in Dutch,
she often has to translate phrases from and to English.
She also needs to find additional information about particular concepts and facts.
Instead of using several tools, such as online dictionaries, definition books and search engines,
she decides to compose a simple service that aggregates all the services she needs.
It should be not to difficult to think of similar scenarios in the context of games,
for example language or culture training games.
A generic solution to this type of scenario(s) is provided by
AMICO (Adaptable Multi-Interface COmmunicator),
which is, according to its developer Zeljko Obrenovic,
a generic platform, used to support rapid prototyping with heterogeneous software services, [AMICO].
AMICO is based on the publish-subscribe design pattern,
which is well suited for integration of loosely-coupled components, and
often used in context-aware and collaborative computing.
A publisher updates a shared data repository without being concerned with whether any subscribers are listening
for updates. In the loosely coupled model,
components can run on different machines in a distributed environment.
An architectural overview of AMICO is given in the figure belew.
1
Our example scenario illustrates the integrated usage of various software components and services.
Service-oriented computing (SoC) has a relatively long history, and may be regarded to have
its roots in object-oriented software development, to the extent that services can be considered as
components which offer their functionality at a sufficiently high level of abstraction. [Eliens2000].
Services provide higher-level abstractions facilitating implementation and configuration of
software applications in a manner that improves productivity and application quality.
Most of the existing work in SoC is concentrated on Web services, which is often seen as a
main way to bring business to the Web [Blevec07]. Service-oriented computing is, however,
not limited to Web services, but embodies key principles such as loose coupling, implementation neutrality,
flexible configurability, persistence, granularity, and teams. Services provide higher-level abstractions
for organizing applications for large scale, open environments. Adding service abstraction on top of heterogeneous open-source components, for example, enables their easier integration with other systems [Obrenovic07b].
In the category of service-oriented computing solutions, we distinguish between 4+1 dimensions:
dimension(s)
- scope -- individual vs. corporate
- platform -- local vs. web-based
- functionality -- data aggregation vs. interaction
- developers -- end-user vs. professionals
Additionally we address the issue of
- licensing -- OS vs. proprietary
Dependent on how a particular application is positioned in the category of service-oriented computing solutions,
different issues play a role.
For example, for corporate applications, security is of vital importance.
In our approach, which is more targeted to the individual end-users,
security plays as consequently less important role.
However, other issues, such as time-management,
are crucial. We introduce the licensing dimension to emphasis that only a very limited number
of the solutions available for the construction of (primarily web-based)
services and mashups is available as an open-source projects [Mashups].
In a general fashion, service-oriented computing requires three mechanisms, or layers of functionality;
service-oriented computing
- service brokering -- to connect services,
- service adapters -- to transform data, and
- integration mechanisms -- to deploy services.
Traditionally, due to their complexity, these layers of functionality necessitated the help of professional
developers with expertise in CORBA, COM or more recently SOAP, to construct suitable end-user applications.
However, with the recent surge of web-based services, exemplified in the increasingly growing number of mashups,
service-oriented computing seems to have come closer to end-users.
That is end-users with non-trivial programming or scripting skills.
For example, some of the existing end-user environments support extension of functionality by providing an access to Web services. Excel's Web Services [ExcelWS], enable end-users to create a code wrapper for Web services, and use functions from this wrapper within the spreadsheets. Limited forms of combinations of EUD and SoC can be found in Web based spreadsheets, such as Google spreadsheets [GoogleSS]. These environments enable receiving updates from remote sources for small number of predefined data types, such as stock prices and currency exchange rates.
As a relatively new phenomenon, mashups introduce end-user service integration
to create composed website or application that combines content from more than one
source into an integrated experience, usually with a end-user interface.
Content used in mashups is typically sourced from a third party via a public interface.
Other methods of sourcing content for mashups include Web feeds (e.g. RSS or Atom),
web services and Screen scraping.
Many people are experimenting with mashups from Google, eBay, Amazon, Flickr, Yahoo [YahooPipes].
Although the dividing line between end-users and professional developers seems to become blurred,
for example where end-users learn how to use scripting languages,
we wish to emphasize that our notion of end-users is quite strict.
An end-user should not be assumed to be able to do any scripting beyond simple formulas
and an occasional conditional expression using the IF-THEN construct.
|
|
|
|
| camera input | voice input | news reader |
2
In comparison with the existing solutions, AMICO has a wider scope than most web-based mashups
or EUD integration platforms, since it supports not only data-aggregation but, as illustrated in the figure above,
provides support also for additional services,
including interaction facilities involving speech recognition and TTS output.
Yet, it is primarily aimed at individual users, supporting the integration of services for which
both a service connection as well as data transformation functionality is available.
End-user development, as we will argue in section 11.4 becomes even more urgent,'where
much of the content and functionality is actually provided by (a community of) users.
How to provide a generic solution for user-added game content is however still an open problem,
for which the service-oriented computing paradigm, however, seems to provide
promising solutions.
(C) Æliens
04/09/2009
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.
