Summary Orchestrating workflows needed for modern scientific data analysis presents a significant research challenge: they are typically executed in a centralized manner such that all data pass through a single compute server known as the engine, which causes unnecessary network traffic that leads to a performance bottleneck. This paper presents a scalable decentralized orchestration system that relies on a functional, high‐level data coordination language for executing workflows. This system consists of distributed execution engines, each of which is responsible for executing part of the overall workflow. It exploits parallelism in the workflow by partitioning it into smaller sub‐workflows and determines the most appropriate engines to execute them using network resource monitoring and placement analysis. This permits the computation logic of the workflow to be moved towards the services providing the data, which improves the overall execution time. The system supports data‐driven execution that allows each sub‐workflow to be executed as soon as the data needed for its execution become available from other sources. Therefore, a scheduling mechanism is not required to manage the order in which the sub‐workflows are orchestrated. This paper provides an evaluation of the proposed system, which demonstrates that decentralized orchestration provides scalability over centralized orchestration. Copyright © 2015 John Wiley & Sons, Ltd.

Service-oriented workflows are typically executed using a centralised orchestration approach that presents significant scalability challenges. These challenges include the consumption of network bandwidth, degradation of performance, and single-points of failure. We provide a decentralised orchestration architecture that attempts to address these challenges. Our architecture adopts a design model that permits the computation to be moved "closer" to services in a workflow. This is achieved by partitioning workflows specified using our simple dataflow language into smaller fragments, which may be sent to remote locations for execution.

Orchestrating centralised service-oriented workflows presents significant scalability challenges that include: the consumption of network bandwidth, degradation of performance, and single points of failure. This paper presents a high-level dataflow specification language that attempts to address these scalability challenges. This language provides simple abstractions for orchestrating large-scale web service workflows, and separates between the workflow logic and its execution. It is based on a data-driven model that permits parallelism to improve the workflow performance. We provide a decentralised architecture that allows the computation logic to be moved "closer" to services involved in the workflow. This is achieved through partitioning the workflow specification into smaller fragments that may be sent to remote orchestration services for execution. The orchestration services rely on proxies that exploit connectivity to services in the workflow. These proxies perform service invocations and compositions on behalf of the orchestration services, and carry out data collection, retrieval, and mediation tasks. The evaluation of our architecture implementation concludes that our decentralised approach reduces the execution time of workflows, and scales accordingly with the increasing size of data sets.

A distributed autonomic system adapts its constituent components to a changing environment. This paper reports on the application of autonomic management to a distributed storage service. We developed a simple analytic model which suggested potential benefit from tuning the degree of concurrency used in data retrieval operations, to suit dynamic conditions. We then validated this experimentally by developing an autonomic manager to control the degree of concurrency. We compared the resulting data retrieval performance with non-autonomic versions, using various combinations of network capacity, membership churn and workload patterns. Overall, autonomic management yielded improved retrieval performance. It also produced a distinct but not significant increase in network usage relative to one non-autonomic configuration, and a significant reduction relative to another.

Wireless sensor networks are often used by experts in many different fields to gather data pertinent to their work. Although their expertise may not include software engineering, these users are expected to produce low-level software for a concurrent, real-time and resource-constrained computing environment. In this paper, we introduce a component-based model for wireless sensor network applications and a language, Insense, for supporting the model. An application is modelled as a composition of interacting components and the application model is preserved in the Insense implementation where active components communicate via typed channels. The primary design criteria for Insense include: to abstract over low-level concerns for ease of programming; to permit worst-case space and time usage of programs to be determinable; to support the fractal composition of components whilst eliminating implicit dependencies between them; and, to facilitate the construction of low footprint programs suitable for resource-constrained devices. This paper presents an overview of the component model and Insense, and demonstrates how they meet the above criteria.

Since the 1980s, various groups have been constructing systems that support a concept known as orthogonal persistence. These systems support objects whose lifetime is independent of the context in which they were created. The benefits of such systems include greater run-time efficiency, strong semantic guarantees about the existence of data and its type, early error checking, and lower construction costs. However, the implementation of persistent systems has been hindered by the lack of support provided by the operating system. This paper examines the implementation of persistent systems on traditional operating systems and on operating systems that directly support persistence, and looks at current attempts to provide flexible architectures that permit persistence to be provided efficiently above the operating system. Copyright © 2000 John Wiley & Sons, Ltd.

A key decision in the design of an operating system is which facilities to provide for the management and composition of the address space. A wide spectrum of schemes exist, ranging from the private process address spaces of Unix through to the recently revived single address space approach. This paper proposes a new model which provides a unified and generalised approach to address space management. The model presents a single abstraction of address spaces which are orthogonal to processes and may be composed in arbitrary ways. The power of the model is demonstrated by case studies which show how shared libraries, a Unix system and a single address space system may be implemented.

Polymorphicabstraction provides the ability to write programs that are independent of the form of the data over which they operate.There are a number of different categories of polymorphic expression-ad hoc and umversal, which includes parametric and inclusion-all of which have many advantages in terms of code reuse and software economics.It has proved difficult to provide efficient implementations of polymorphism.Here, we address this problem and describe a new technique that can implement all forms of polymorphism, use a conventional machine architecture, and support nonuniform data representations.Furthermore, the method ensures that any extra cost of implementation applies to polymorphic forms only, and allows such polymorphic forms to persist over program invocations.

In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.

The need to examine data structures often occurs in programming language and database management systems. In this paper we describe how a browser for a strongly type programming language (PS-algol) may be written in a type-secure manner in a closed persistent environment. This is achieved without resorting to magic or having to break the type rules of the language by exploiting a compiler that is an object with full civil rights in the environment. The use and impact of such an object is discussed.

Abstract The facilities of the PS‐algol programming language are described in this paper to show how they may be used to provide an integrated graphics programming environment. The persistent store mechanism and the secure transaction facilities of the language provide the basic environment in which an integrated system may be implemented. This is augmented by data types and operations to support line drawings and raster graphics. The combination of these mechanisms may be used to provide the integrated graphics programming environment.

Abstract The facilities of the PS‐algol programming language are described in this paper to show how they may be used to provide an integrated programming support environment. The persistent store mechanism and the secure transaction facilities provide the basic environment in which an integrated system may be implemented. In particular the paper makes use of the data type picture of PS‐algol to show how such an environment may be built for a graphics system ideal for use with a medium range computer workstation. An implementation of a picture editor on the ICL PERQ workstation is described to show the utility of the system.