The strong divide between applications and the network control plane is desirable, but keeps the network in the dark regarding the ultimate purpose of applications and, as a result, is unable to optimize for these. An alternative approach is for applications to declare to the network their abstract desires; e.g. “I require group multicast”, or “I will run within a local domain and am latency sensitive”. Such an enriched semantic has the potential to enable the network to better fulfill application intent, while also helping optimize network resource usage across applications. We refer to this approach as intent driven networking (IDN). We sketch an incrementally-deployable design to serve as a stepping stone towards a practical realization of IDN within today's Internet.

The world's computing infrastructure is increasingly differentiating into self-contained sub-systems (e.g. Internet of Things installations, clouds, VANETs, ...), which are post-hoc composed to generate value-added functionality (“systems of systems”). Today, however, such system-of-systems composition is typically carried out in an ad-hoc and infrastructure-dependent manner, with obvious associated disadvantages. In this paper, we propose a generalised system-of-systems-oriented programming approach that enables programmers to manage the composition of systems without a need for intimate knowledge of their internals, and also facilitates dynamic and spontaneous system composition, as systems discover each other opportunistically in their environment.

Wireless sensor and actuator networks (WSANs) will increasingly require support for managed software evolution: that is, systematic, ongoing, efficient and nondisruptive means of updating the software running on the nodes of a WSAN. While aspects of this requirement have been examined in the literature, the big picture remains largely untouched, resulting in the generally static WSAN deployments we see today. In this article, we propose a comprehensive approach to managed software evolution. Our approach has the following key features: (i) it supports divergent evolution of the WSAN's software, such that different nodes can evolve along different lines (e.g., to meet the needs of different stakeholders, or to address localized adaptations) and (ii) it supports both instructed and autonomous evolution such that nodes can be instructed to change their software configuration or can evolve their own configuration (e.g., to manage rapidly-changing environmental conditions where remote micromanagement would be infeasible due to the high latency of the WSAN environment). We present the four intra-WSAN protocols that comprise our solution, along with an accompanying server-side infrastructure, and evaluate our approach at scale.

In this demo we show how the Lorien operating system [5] supports lightweight, efficient and safe online channges to any aspect of the software running on sensor nodes - and how this promotes reuse of deployed sensor networks through run-time software evolution.

Component-based software engineering has recently emerged as a promising solution to the development of system-level software. Unfortunately, current approaches are limited to specific platforms and domains. This lack of generality is particularly problematic as it prevents knowledge sharing and generally drives development costs up. In the past, we have developed a generic approach to component-based software engineering for system-level software called OpenCom. In this paper, we present OpenComL an instantiation of OpenCom to Linux environments and show how it can be profiled to meet a range of system-level software in Linux environments. For this, we demonstrate its application to constructing a programmable router platform and a middleware for parallel environments.

The innate dynamicity and complexity of mobile ad-hoc networks (MANETs) has resulted in numerous ad-hoc routing protocols being proposed. Furthermore, numerous variants and hybrids continue to be reported in the literature. This diversity appears to be inherent to the field-it seems unlikely that there will ever be a ‘one-size-fits-all’ solution to the ad-hoc routing problem. However, typical deployment environments for ad-hoc routing protocols still force the choice of a single fixed protocol; and the resultant compromise can easily lead to sub-optimal performance, depending on current operating conditions. In this paper we address this problem by exploring a framework approach to the construction and deployment of ad-hoc routing protocols. Our framework supports the simultaneous deployment of multiple protocols so that MANET nodes can switch protocols to optimise to current operating conditions. The framework also supports finer-grained dynamic reconfiguration in terms of protocol variation and hybridisation. We evaluate our framework by using it to construct and (simultaneously) deploy two popular ad-hoc routing protocols (DYMO and OLSR), and also to derive fine-grained variants of these. We measure the performance and resource overhead of these implementations compared to monolithic ones, and find the comparison to be favourable to our approach.

In order to provide an increasing number of functionalities and benefit from sophisticated and application-tailored services from the network, distributed applications are led to integrate an ever-widening range of networking technologies. As these applications become more complex, this requirement for 'network heterogeneity' is becoming a crucial issue in their development. Although progress has been made in the networking community in addressing such needs through the development of network overlays, we claim in this paper that the middleware community has been slow to integrate these advances into middleware architectures, and, hence, to provide the foundational bedrock for heterogeneous distributed applications. In response, we propose our 'open overlays' framework. This framework, which is part of a wider middleware architecture, accommodates 'overlay plug-ins', allows physical nodes to support multiple overlays, supports the stacking of overlays to create composite protocols, and adopts a declarative approach to configurable deployment and dynamic reconfigurability. The framework has been in development for a number of years and supports an extensive range of overlay plug-ins including popular protocols such as Chord and Pastry. We report on our experiences with the open overlays framework, evaluate it in detail, and illustrate its application in a detailed case study of network heterogeneity.

Abstract Flooding is a growing problem, which affects more than 10% of the U.K. population. The cost of damage caused by flooding correlates closely with the warning time given before a flood event, making flood monitoring and prediction critical to minimizing the cost of flood damage. This paper describes a wireless sensor network (WSN) for flood warning, which is capable of not only integrating with remote fixed‐network grids for computationally intensive flood modelling purposes but also performing on‐site grid computation. This functionality is supported by the reflective and component‐based GridKit middleware, which provides support for both WSN and grid application domains. Copyright © 2007 John Wiley & Sons, Ltd.

Component-based software structuring principles are now commonplace at the application level; but componentization is far less established when it comes to building low-level systems software. Although there have been pioneering efforts in applying componentization to systems-building, these efforts have tended to target specific application domains (e.g., embedded systems, operating systems, communications systems, programmable networking environments, or middleware platforms). They also tend to be targeted at specific deployment environments (e.g., standard personal computer (PC) environments, network processors, or microcontrollers). The disadvantage of this narrow targeting is that it fails to maximize the genericity and abstraction potential of the component approach. In this article, we argue for the benefits and feasibility of a generic yet tailorable approach to component-based systems-building that offers a uniform programming model that is applicable in a wide range of systems-oriented target domains and deployment environments. The component model, called OpenCom , is supported by a reflective runtime architecture that is itself built from components. After describing OpenCom and evaluating its performance and overhead characteristics, we present and evaluate two case studies of systems we have built using OpenCom technology, thus illustrating its benefits and its general applicability.

Due to the inherent nature of their heterogeneity, resource scarcity and dynamism, the provision of middleware for future networked embedded environments is a challenging task. In this paper we present a middleware approach that addresses these key challenges; we also discuss its application in a realistic networked embedded environment. Our application scenario involves fire management in a road tunnel that is instrumented with networked sensor and actuator devices. These devices are able to reconfigure their behaviour and their information dissemination strategies as they become damaged under emergency conditions, and firefighters are able to coordinate their operations and manage sensors and actuators through dynamic reprogramming. Our supporting middleware is based on a two-level architecture: the foundation is a language-independent, component-based programming model that is sufficiently minimal to run on any of the devices typically found in networked embedded environments. Above this is a layer of software components that offer the necessary middleware functionality. Rather than providing a monolithic middleware 'layer', we separate orthogonal areas of middleware functionality into self-contained components that can be selectively and individually deployed according to current resource constraints and application needs. Crucially, the set of such components can be updated at runtime to provide the basis of a highly dynamic and reconfigurable system

The papers in this special issue paint a representative picture of current research issues in Grid computing, in the form of a selection of papers from the Third International Workshop on Middleware for Grid Computing (MGC) [1].All of the papers have been extended and thoroughly revised from the original workshop versions.Previous special issues on selected papers of [2] and [3] have been published in [4] and [5].The papers collected in this special issue address some current issues in middleware for Grid computing.Paventhan et al. [6] describe CoG toolkits enabling Grid application development using commodity development frameworks.Desertot et al. [7] describe how Grid environments can lead to powerful architectures and show that this is the case for edge computing.Zhao et al. [8] propose SVGrid, a Secure Virtual Grid running environment, to protect sensitive files and networks for Grid computers.Santos et al. [9] analyze three accounting schemes to support the implementation of an autonomous reputation-based allocation mechanism for peer-to-peer Grids.Nascimento et al. [10] present the allocation of application processes to the available processors by employing hybrid scheduling in an EasyGrid AMS environment to improve the performance of Grid MPI applications.Yarmolenko and Sakellariou [11] discuss the extensions to the WS-Agreement specification, and their experiences and conclusions are drawn are in the context of agreement-based job management systems.Vargas et al. [12] discuss the assumption of submitting a huge number of tasks and present an elegant solution to the problem by a hierarchical model that can distribute the submission load.In the remainder of this editorial we would like to take a step back from the current research topics to articulate a vision of what Grid computing might be like in the next decade or two.This 'potential future' is influenced by a middleware perspective (as opposed to a Grid user perspective) and is therefore necessarily biased.In particular, we will lay emphasis on the architecture of the 'lowlevel' Grid infrastructure in terms of computer systems, their interconnectivity, and their system-level software.The motivation for offering this vision is to counterbalance, in a small way, the tendency for Grid research efforts to focus on short-term development.In addition to the pragmatic application development that is indeed important and necessary, the long-term health of Grid computing will require a complementary thread of architectural work not unduly influenced by short-term imperatives.

Network processors (NPs) are set to play a key role in the next generation of networking technology. They have the performance of ASIC-based routers whilst offering a high degree of programmability. However, the programmability potential of NPs can only be realized with appropriate software. In this paper, we argue that specialized software to support runtime reconfiguration is needed to fully exploit the potential of NPs. We first justify supporting runtime reconfiguration on NPs by offering real-world scenarios and discussing the issues associated with these. We then demonstrate how runtime reconfiguration can be achieved in practice through a case study of our component-based programming approach on the Intel IXP2400 NP

Next generation embedded systems will be composed of large numbers of heterogeneous devices. These will typically be resource-constrained, will use different operating systems, and will be connected through different types of network interfaces. Additionally, they may be mobile and/or form ad-hoc networks with their peers, and will need to be adaptive to changing conditions based on context-awareness. As an example of these system we consider disaster recovery scenarios where large numbers of different devices need to interconnect in an ad-hoc manner. In this respect, our goal is the provisioning of a middleware framework for such system environments. Our approach is based on a small and efficient middleware kernel supporting highly modularised and customisable component-based middleware services. These services can be tailored for specific embedded environments, and are runtime-reconfigurable to support adaptivity. This paper describes a demonstration that highlights some of the features available in our middleware. In particular, we focus on heterogeneity handling by showing our middleware running on resource-rich as well as resource-constrained devices, and on adaptivity features by demonstrating runtime reprogramming and on-the-fly component deployment

Current approaches to flood monitoring (e.g. in river valleys) involve statically deploying depth and ultrasoundbased flow sensors across flood-prone areas, and feeding the collected data off-site (e.g. using GSM) to grid-based

We present and evaluate a generic approach to the repair of overlay networks which identifies general principles of overlay repair and embodies these as a reusable service. At the heart of our approach is an algorithm that discovers the extent of a failed section of any type of overlay, and assigns responsibility to carry out the repair. The repair strategy itself is 'pluggable' and can be tailored to the requirements of a specific overlay type or instance. Our approach is efficient in terms of the number of repair-related message exchanges it incurs; scalable in that it involves only nodes in the locality of the failed section of the overlay; and resilient in that it correctly handles cases in which multiple adjacent nodes fail simultaneously, and it tolerates new failures that occur while a repair is underway. The benefits of our approach are that: (i) it extracts and encapsulates best practice in repair for overlays; (ii) it simplifies the design and implementation of new overlays (because repair issues can be treated orthogonally to basic functionality); and (iii) it supports tailorable levels of dependability for overlays, including pluggable repair strategies

The cost of damage caused by flooding is directly related to the warning-time given before a flood occurs. Therefore, improving the coverage, accuracy and reliability of flood prediction systems is of great importance. This paper proposes a novel Grid-based approach to supporting flood prediction through the use of embedded sensor nodes equipped with wireless networking technology. These nodes implement a light-weight Grid capable of collecting and transmitting data gathered by flood sensors for off-site analysis. Additionally, the nodes are capable of performing basic on-site analysis that is used to inform system behavior. The proposed system utilizes Lancaster's next-generation component-based Grid middleware platform 'GridKit', which offers inherent support for reconfiguration, embedded devices and heterogeneous network technologies, making it ideally suited to this application.

Abstract Significant progress has been made in the design and development of Grid middleware which, in its present form, is founded on Web services technologies. However, we argue that present‐day Grid middleware is severely limited in supporting projected next‐generation applications which will involve pervasive and heterogeneous networked infrastructures, and advanced services such as collaborative distributed visualization. In this paper we discuss a new Grid middleware framework that features (i) support for advanced network services based on the novel concept of pluggable overlay networks, (ii) an architectural framework for constructing bespoke Grid middleware platforms in terms of ‘middleware domains’ such as extensible interaction types and resource discovery. We believe that such features will become increasingly essential with the emergence of next‐generation e‐Science applications. Copyright © 2005 John Wiley & Sons, Ltd.

In this paper the RUNES approach to the development of software for networked embedded systems is described. There is a need for a program platform with abstractions that are able to span the full range of heterogeneous embedded systems, and which also offers consistent mechanisms with which to configure, deploy, and dynamically reconfigure networked embedded systems software. This paper discusses the need of such a programming platform. The work is being carried out in the context of the RUNES project (reconfigurable, ubiquitous, and networked embedded systems) which has the general goal of developing an architecture for networked embedded systems that encompasses dedicated radio layers, networks

Recent research has recognised the potential of coupling ADLs with underlying runtime environments to support systematic and integrated "specification-todeployment" architectures. However, while some promising results have been obtained, much of this research has not considered the crucial issue of causally-connected dynamic reconfiguration and has considered only domain-specific areas. In this paper we discuss a specification-to-deployment architecture called Plastik that employs an extended generalpurpose ADL and is underpinned by an efficient runtime that is suited both for high-level application development and low-level systems development (e.g. embedded systems). Runtime reconfiguration is supported both at the ADL level and at the runtime level, and both programmed reconfiguration and adhoc reconfiguration are supported. The paper focuses on the mapping of ADL-level specifications to runtime instantiations and on the necessary runtime support for causally-connected dynamic reconfiguration.

Reflection is widely acknowledged as a useful mechanism for facilitating the run-time adaptation/ reconfiguration of software. Often, however, it is also thought to impose intolerably high overheads in performance-critical systems software environments like middleware platforms, operating systems, or programmable routers. In this paper we argue that there are many varieties of reflection (i.e. many types of 'meta-models') and that some of these in fact impose zero or negligible overhead. We further argue that in many cases, particularly cases involving highly dynamic software environments, reflection can actually enhance performance by laying open choices of alternative mechanisms that are best suited to current environmental conditions. Finally, we discuss the case of interception meta-models which, in many implementations, do lead to significant performance problems, and present our experience to date in attempting to minimise these problems.

There has been a significant body of research conducted into various structured and unstructured overlay network protocols. Both paradigms have advantages for specific application domains and researchers are beginning to examine the benefits of using hybridized systems. We hypothesize that resource awareness and adaptation are essential to the efficient exploitation of the resources available on the diverse nodes which compose peer-to-peer networks. To support this, we propose a hybrid peer-to-peer model which uses an unstructured decentralised network layered on top of a structured overlay to provide support for multiple levels of adaptation.

Thorough testing of distributed systems, particularly peer-to-peer systems can prove difficult due to the problems inherent in deploying, controlling and monitoring many nodes simultaneously. This problem will only increase as the scale of distributed systems continues to grow. This framework implements a test bed environment using a semi-centralized peer-to-peer network as a substrate for sharing resources made available from standard PCs. This framework automates the process of test-case deployment using a combination of reflection and aspect oriented programming. This allows 'point-and-click' publishing of software onto the test-bed. Our framework also provides a common monitoring, control and logging interface for all nodes running on the network. Together, these features greatly reduce deployment-time for real-world test scenarios. Automated insertion and removal of test code also ensures that the testing process does not compromise the correctness of the final system.

Abstract Significant progress has been made in the design and development of object‐based distributed systems and, more recently, in component‐based reflective middleware platforms—i.e. middleware platforms that, through reflection, can be flexibly configured, and runtime adapted/reconfigured—especially in terms of non‐functional properties like quality of service (QoS). In this paper we consider how ideas and principles from such platforms can usefully be applied in a Grid context, specifically, an Open Grid Services Architecture (OGSA) context. To this end, we identify weaknesses in OGSA in the areas of generic service provision, scalability/performance engineering, and, especially, lack of support for QoS specification and realization, and suggest how these can be alleviated. We believe that such areas will become increasingly important as sophisticated e‐Science applications start to exploit the potential of OGSA's service‐based architecture. We also report on our current research on developing a binding‐type framework, a resource management framework, and a set of performance optimizations for an ongoing OGSA implementation we are working on. Copyright © 2004 John Wiley & Sons, Ltd.

One of the most significant limitations of current middleware platforms, both commercial and research, is that they typically support only a small, pre-defined, set of fundamental binding types (e.g., remote method invocation). This restriction limits the scope of platforms in that they cannot easily accommodate, or easily be extended to accommodate, richer or more specialized forms of interaction (e.g. events, media streaming, multicast, and many others discussed in the paper). This paper describes a highly extensible, component-oriented framework for the definition and implementation of such binding types. We motivate and specify the framework in detail and evaluate it by providing examples of its use.

The first generation of peer-to-peer file sharing systems followed the traditional client-server paradigm. However, legality and scalability issues have driven the development of decentralized file sharing protocols; the most popular of these being Gnutella. To date, such systems have been unable to match the quality of service (QoS) offered by centralized architectures. AGnuS improves QoS on Gnutella by increasing file availability, improving network friendliness and increasing file quality. This is achieved by layering caching, load balancing, content-based routing and filtering services on top of the core Gnutella protocol.

Abstract Threads play a key role in object‐based middleware platforms. Implementers of such platforms can select either kernel or user‐level threads, but neither of these options are ideal. In this paper we introduce Application Scheduler Contexts (ASCs) which flexibly combine both types of thread and thereby attempt to exploit the advantages of each. Multiple ASCs can co‐exist, each with their own concurrency semantics and scheduling policy. ASCs also support quality of service (QoS) configurability, and define their own QoS schema. We show how ASCs can be efficiently implemented and how they can usefully be exploited in middleware environments. We also provide a quantitative evaluation that demonstrates the feasibility of the ASC concept in performance terms. Copyright © 2002 John Wiley & Sons, Ltd.

The mobile Internet is enabling a broad range of new applications that dynamically obtain information that is relevant to their current location. This type of application would greatly benefit from generic mechanisms for supporting the association between network resources and physical space, but existing systems are typically based on vertical approaches valid only for narrow application scenarios. This paper argues that a comprehensive solution to this issue should address the important challenges of heterogeneity and openness, and proposes an approach based on the concept of location-based service, i.e. a service whose usage is associated with physical space, as a generic abstraction to support the development of location-dependent systems. The paper describes a model for associating location scopes with services, an architecture to support the discovery of location-based services on the Internet, and a prototype infrastructure in which several services and applications have been developed for validating the architecture.

Two current trends in distributed computing are the emergence of standardized distributed object platforms such as CORBA, and the increasing use of continuous media data types. This paper describes and evaluates a platform which supports both standard CORBA interactions and continuous media interactions in a fully integrated environment. The platform is implemented as a self-contained support infrastructure (GOPI core) and a separate ‘personality’ that sits on top of the infrastructure and provides a CORBA API. The platform user can create both request/reply oriented and stream oriented bindings with quality of service specifications that are honoured (as far as possible) by the infrastructure. A framework for quality of service management which involves the monitoring and adaptation of quality levels is also supported. The level of performance attained by the platform provides evidence of the feasibility of natively supporting continuous media in a distributed object platform environment. Copyright © 2000 John Wiley & Sons, Ltd.

The traditional approach to developing middleware platforms is to adopt a "black box" philosophy whereby the platform offers a fixed programming model to applications together with fixed per-platform implementations. In this paper, we describe research which is exploring an open approach to the implementation of middleware platforms. Our motivation is to accommodate the demanding requirements for quality-of-service (QoS) adaptation as imposed by mobile multimedia applications. We use an extended CORBA computational model featuring the concept of explicit open bindings. This provides an architectural framework for openness and QoS adaptation. The paper concludes by considering the more general application of an open systems philosophy; in particular, we introduce the concept of reflective middleware.

A new framework is required for the consistent and coordinated construction and configuration of multimedia components across heterogeneous distributed object environments. The paper presents a distributed multimedia component architecture which extends beyond the current well developed distributed object models, such as the Common Object Request Broker Architecture (CORBA) and the Microsoft Distributed Component Object Model (DCOM) models, to support additional mechanisms and abstractions for continuous media stream interactions aimed particularly at distributed multimedia applications. This framework additionally includes distributed resource management and dynamic Quality of Service (QoS) monitoring and adaptation in order to support the implementation of complex distributed multimedia applications over heterogeneous networks and end-systems. The multimedia component architecture (MCA) presented is being used as the middleware component of a comprehensive resource management architecture for distributed applications (Waddington, 1997).

Distributed audio and video applications need to adapt to fluctuations in delivered quality of service (QoS).By trading off temporal and spatial quality to available bandwidth, or manipulating the playout time of continuous media in response to variation in delay, audio and video flows can be made to adapt to fluctuating QoS with minimal perceptual distortion.In this paper we describe the implementation of a QoS adaptive transport system that incorporates a QoS oriented API and a range of mechanisms to assist applications in exploiting QoS and adapting to fluctuations in QoS.The system, which is an instantiation of the QoS Architecture (QoS-A), is implemented in a multi ATM switch network environment with Linux based PC end systems and continuous media file servers.A performance evaluation of the system configured to support Video-on-Demand application scenario is presented and discussed.'ACM Multimcdia 96, Boston MA USA

One of the major requirements of distributed multimedia applications is the need to maintain often complex, real-time synchronization constraints. More specifically, it is necessary to be able to manage arbitrary intra- and inter-media synchronization across activities in the distributed environment. Furthermore, it is important that such developments are integrated into emerging object-oriented standards for distributed computing. This paper presents an object-oriented programming model and associated implementation to meet these requirements. The main concepts behind the proposed approach are, firstly, the use of reactive objects for real-time control and synchronization and, secondly, quality of service controlled bindings for predictable communication between objects. The flexibility of the approach is demonstrated by three contrasting examples of real-time synchronization. The implementation extends the real-time capabilities of the Chorus micro-kernel by introducing the concepts of rtports, rthandlers and quality of service controlled connections. The paper demonstrates how reactive objects and bindings are realized on this infrastructure.

We describe the design of an application platform able to run distributed real-time and multimedia applications alongside conventional UNIX programs. The platform is embedded in a microkernel/PC environment and supported by an ATM-based, QoS-driven communications stack. In particular, we focus on resource-management aspects of the design and deal with CPU scheduling, network resource-management and memory-management issues. An architecture is presented that guarantees QoS levels of both communications and processing with varying degrees of commitment as specified by user-level QoS parameters. The architecture uses admission tests to determine whether or not new activities can be accepted and includes modules to translate user-level QoS parameters into representations usable by the scheduling, network, and memory-management subsystems.>

There is currently considerable interest in developing multimedia applications in open distributed systems. However, it is now becoming clear that existing architectures for open distributed systems do not support the particular requirements of continuous media types such as digital audio and video. This is particularly the case in the important areas of quality of service support and real-time synchronization. This paper presents results from the Sumo project which aims at supporting continuous media types within the framework defined by the draft Open Distributed Processing standard. The paper advocates the use of synchronous languages within this framework for specifying and implementing real-time synchronization and QoS monitoring. A computational model and the realization of an infrastructure supporting this view are presented.

The integration of distributed multimedia systems around the unifying theme of quality of service (QOS) is addressed. A set of key QOS requirements is presented and mapped onto a provisional QOS architecture (QOS-A) that has emerged from a experimental system designed and implemented at Lancaster. The scope of the discussion is limited to aspects of a QOS-A for the support of continuous media communications. Also, the focus is on asynchronous transfer mode (ATM) at the network layer rather than the full range of multiservice networks. Functions and mechanisms for QOS support are examined and placed within the evolving QOS-A.>

The combination of high-speed multiservice networks and multimedia workstations offers considerable potential for the development of distributed multimedia applications. A key problem is how to integrate continuous-media types such as audio and video into a distributed workstation environment. An experimental system architecture based on a specialized multimedia network interface that attempts to provide this integration is described. The design and implementation of this system are discussed in depth in terms of workstation enhancement and distributed system support. A new approach to the problem of media synchronization is introduced, and the importance of quality of service in the architecture is highlighted. Experiences encountered during this work are described, comparison with other approaches is made, and likely future developments in multimedia network interfacing are discussed.>

The desire to transfer continuous media such as digital audio and video across packet switched networks imposes a number of new requirements on transport level communication services. This paper identifies a number of these requirements in the context of an experimental distributed multimedia infrastructure, and reports on research which addresses some of the associated issues. Particular attention is paid to two areas: (i) extended Quality of Service (QoS) provision; and (ii) support for the co-ordination of multiple related connections. We then describe an application level service, known as an orchestrator, which performs synchronisation functions over multiple related transport connections. We also outline the design and implementation of a continuous media transport service which meets the identified requirements. Finally, we outline the way in which the orchestrator and transport services are integrated into an object-based distributed multimedia application platform.