988 research outputs found
Abstract Interactions and Interaction Refinement in Model-Driven Design
In a model-driven design process the interaction between application parts can be described at various levels of platform-independence. At the lowest level of platform-independence, interaction is realized by interaction mechanisms provided by specific middleware platforms. At higher levels of platform-independence, interaction must be described in such a way that it can be further refined and realized onto a number of different middleware platforms, each with its particular interaction mechanisms and implementation constraints. In this paper, we investigate concepts that support interaction design at various levels of middleware-platform-independence. Also, we propose design operations for interaction refinement. The application of these operations to source designs results in target designs that take into account implementation constraints imposed by platforms, while preserving characteristics prescribed in source designs
Adaptive object management for distributed systems
This thesis describes an architecture supporting the management of pluggable software components and evaluates it against the requirement for an enterprise integration platform for the manufacturing and petrochemical industries. In a distributed environment, we need mechanisms to manage objects and their interactions. At the least, we must be able to create objects in different processes on different nodes; we must be able to link them together so that they can pass messages to each other across the network; and we must deliver their messages in a timely and reliable manner. Object based environments which support these services already exist, for example ANSAware(ANSA, 1989), DEC's Objectbroker(ACA,1992), Iona's Orbix(Orbix,1994)Yet such environments provide limited support for composing applications from pluggable components. Pluggability is the ability to install and configure a component into an environment dynamically when the component is used, without specifying static dependencies between components when they are produced. Pluggability is supported to a degree by dynamic binding. Components may be programmed to import references to other components and to explore their interfaces at runtime, without using static type dependencies. Yet thus overloads the component with the responsibility to explore bindings. What is still generally missing is an efficient general-purpose binding model for managing bindings between independently produced components. In addition, existing environments provide no clear strategy for dealing with fine grained objects. The overhead of runtime binding and remote messaging will severely reduce performance where there are a lot of objects with complex patterns of interaction. We need an adaptive approach to managing configurations of pluggable components according to the needs and constraints of the environment. Management is made difficult by embedding bindings in component implementations and by relying on strong typing as the only means of verifying and validating bindings. To solve these problems we have built a set of configuration tools on top of an existing distributed support environment. Specification tools facilitate the construction of independent pluggable components. Visual composition tools facilitate the configuration of components into applications and the verification of composite behaviours. A configuration model is constructed which maintains the environmental state. Adaptive management is made possible by changing the management policy according to this state. Such policy changes affect the location of objects, their bindings, and the choice of messaging system
Models of higher-order, type-safe, distributed computation over autonomous persistent object stores
A remote procedure call (RPC) mechanism permits the calling of procedures in another
address space. RPC is a simple but highly effective mechanism for interprocess communication
and enjoys nowadays a great popularity as a tool for building distributed applications.
This popularity is partly a result of their overall simplicity but also partly a consequence
of more than 20 years of research in transpaxent distribution that have failed to deliver
systems that meet the expectations of real-world application programmers.
During the same 20 years, persistent systems have proved their suitability for building
complex database applications by seamlessly integrating features traditionally found in
database management systems into the programming language itself. Some research. effort
has been invested on distributed persistent systems, but the outcomes commonly suffer
from the same problems found with transparent distribution.
In this thesis I claim that a higher-order persistent RPC is useful for building distributed
persistent applications. The proposed mechanism is: realistic in the sense that it uses
current technology and tolerates partial failures; understandable by application programmers;
and general to support the development of many classes of distributed persistent
applications.
In order to demonstrate the validity of these claims, I propose and have implemented three
models for distributed higher-order computation over autonomous persistent stores. Each
model has successively exposed new problems which have then been overcome by the next
model. Together, the three models provide a general yet simple higher-order persistent
RPC that is able to operate in realistic environments with partial failures.
The real strength of this thesis is the demonstration of realism and simplicity. A higherorder
persistent RPC was not only implemented but also used by programmers without
experience of programming distributed applications. Furthermore, a distributed persistent
application has been built using these models which would not have been feasible with a
traditional (non-persistent) programming language
Building object-oriented software with the D-Bus messaging system
Object-oriented programming is a widely adopted paradigm for desktop software development.
This paradigm partitions software into separate entities, objects, which consist
of data and related procedures used to modify and inspect it. The paradigm has evolved
during the last few decades to emphasize decoupling between object implementations, via
means such as explicit interface inheritance and event-based implicit invocation.
Inter-process communication (IPC) technologies allow applications to interact with each
other. This enables making software distributed across multiple processes, resulting in a
modular architecture with benefits in resource sharing, robustness, code reuse and security.
The support for object-oriented programming concepts varies between IPC systems.
This thesis is focused on the D-Bus system, which has recently gained a lot of users, but
is still scantily researched. D-Bus has support for asynchronous remote procedure calls
with return values and a content-based publish/subscribe event delivery mechanism.
In this thesis, several patterns for method invocation in D-Bus and similar systems are
compared. The patterns that simulate synchronous local calls are shown to be dangerous.
Later, we present a state-caching proxy construct, which avoids the complexity of
properly asynchronous calls for object inspection. The proxy and certain supplementary
constructs are presented conceptually as generic object-oriented design patterns. The
e ect of these patterns on non-functional qualities of software, such as complexity, performance
and power consumption, is reasoned about based on the properties of the D-Bus
system. The use of the patterns reduces complexity, but maintains the other qualities at a
good level.
Finally, we present currently existing means of specifying D-Bus object interfaces for the
purposes of code and documentation generation. The interface description language used
by the Telepathy modular IM/VoIP framework is found to be an useful extension of the
basic D-Bus introspection format.Siirretty Doriast
Adapting Agent Platforms to Web Service Environments
This master thesis tries to address the above-mentioned issues by creating an agent plat-
form suitable for encapsulating web-services into agents, providing them with typical
agent capabilities (such as learning or complex communication and reasoning mechanisms).
The objective of this point is to create a generic, modular agent platform that is able to
run lightweight agents. The agents should be able to easily invoke web-services, e ectively
encapsulating them. They also should be able to easily coordinate for composing the invoked
services in order to perform complex tasks. Thus, the platform must provide facilities to
allow the agents perform these service invocations
Ada (trademark) projects at NASA. Runtime environment issues and recommendations
Ada practitioners should use this document to discuss and establish common short term requirements for Ada runtime environments. The major current Ada runtime environment issues are identified through the analysis of some of the Ada efforts at NASA and other research centers. The runtime environment characteristics of major compilers are compared while alternate runtime implementations are reviewed. Modifications and extensions to the Ada Language Reference Manual to address some of these runtime issues are proposed. Three classes of projects focusing on the most critical runtime features of Ada are recommended, including a range of immediately feasible full scale Ada development projects. Also, a list of runtime features and procurement issues is proposed for consideration by the vendors, contractors and the government
Software Packaging
Many computer programs cannot be easily integrated because their
components are distributed and heterogeneous, i.e., they are implemented
in diverse programming languages, use different data representation
formats, or their runtime environments are incom patible. In many cases,
programs are integrated by modifying their components or interposing
mechanisms that handle communication and conversion tasks. For example,
remote procedure call (RPC) helps integrate heterogeneous, distributed
programs. When conf iguring such programs, however, mechanisms like RPC
must be used explicitly by software developers in order to integrate
collections of diverse components. Each collection may require a unique
integration solution. This thesis describes a process called software
packaging that automatically determines how to integrate a diverse
collection of computer programs based on the types of components involved
and the capabilities of available translators and adapters in an
environment. Whereas previous efforts focused solely on integration
mechanisms, software packaging provides a context that relates such
mechanisms to software integration processes. We demonstrate the value of
this approach by reducing the cost of configuring applications whose
components are distributed and implemented in different programming
languages. Our software packaging tool subsumes traditional integration
tools like UNIX MAKE by providing a rule-based approach to software
integration that is independent of execution environments.
(Also cross-referenced as UMIACS-TR-93-56
- …