Collaboration across institutional boundaries is widespread and increasing today. It depends on federations sharing data that often have governance rules or external regulations restricting their use. However, the handling of data governance rules (aka. data-use policies) remains manual, time-consuming and error-prone, limiting the rate at which collaborations can form and respond to challenges and opportunities, inhibiting citizen science and reducing data providers' trust in compliance. Using an automated system to facilitate compliance handling reduces substantially the time needed for such non-mission work, thereby accelerating collaboration and improving productivity. We present a framework, Dr.Aid, that helps individuals, organisations and federations comply with data rules, using automation to track which rules are applicable as data is passed between processes and as derived data is generated. It encodes data-governance rules using a formal language and performs reasoning on multi-input-multi-output data-flow graphs in decentralised contexts. We test its power and utility by working with users performing cyclone tracking and earthquake modelling to support mitigation and emergency response. We query standard provenance traces to detach Dr.Aid from details of the tools and systems they are using, as these inevitably vary across members of a federation and through time. We evaluate the model in three aspects by encoding real-life data-use policies from diverse fields, showing its capability for real-world usage and its advantages compared with traditional frameworks. We argue that this approach will lead to more agile, more productive and more trustworthy collaborations and show that the approach can be adopted incrementally. This, in-turn, will allow more appropriate data policies to emerge opening up new forms of collaboration.

The DARE platform enables researchers and their developers to exploit more capabilities to handle complexity and scale in data, computation and collaboration. Today's challenges pose increasing and urgent demands for this combination of capabilities. To meet technical, economic and governance constraints, application communities must use use shared digital infrastructure principally via virtualisation and mapping. This requires precise abstractions that retain their meaning while their implementations and infrastructures change. Giving specialists direct control over these capabilities with detail relevant to each discipline is necessary for adoption. Research agility, improved power and retained return on intellectual investment incentivise that adoption. We report on an architecture for establishing and sustaining the necessary optimised mappings and early evaluations of its feasibility with two application communities.

The DARE platform has been designed to help research developers deliver user-facing applications and solutions over diverse underlying e-infrastructures, data and computational contexts. The platform is Cloud-ready, and relies on the exposure of APIs, which are suitable for raising the abstraction level and hiding complexity. At its core, the platform implements the cataloguing and execution of fine-grained and Python-based dispel4py workflows as services. Reflection is achieved via a logical knowledge base, comprising multiple internal catalogues, registries and semantics, while it supports persistent and pervasive data provenance. This paper presents design and implementation aspects of the DARE platform, as well as it provides directions for future development.

We present a practical approach for provenance capturing in Data-Intensive workflow systems. It provides contextualisation by recording injected domain metadata with the provenance stream. It offers control over lineage precision, combining automation with specified adaptations. We address provenance tasks such as extraction of domain metadata, injection of custom annotations, accuracy and integration of records from multiple independent workflows running in distributed contexts. To allow such flexibility, we introduce the concepts of programmable Provenance Types and Provenance Configuration. Provenance Types handle domain contextualisation and allow developers to model lineage patterns by re-defining API methods, composing easy-to-use extensions. Provenance Configuration, instead, enables users of a Data-Intensive workflow execution o prepare it for provenance capture, by configuring the attribution of Provenance Types to components and by specifying grouping into semantic clusters. This enables better searches over the lineage records. Provenance Types and Provenance Configuration are demonstrated in a system being used by computational seismologists. It is based on an extended provenance model, S-PROV.

With the needs of science and business, data sharing and re-use has become an intensive activity for various areas. In many cases, governance imposes rules concerning data use, but there is no existing computational technique to help data-users comply with such rules. We argue that intelligent systems can be used to improve the situation, by recording provenance records during processing, encoding the rules and performing reasoning. We present our initial work, designing formal models for data rules and flow rules and the reasoning system, as the first step towards helping data providers and data users sustain productive relationships.

This paper presents the first complete, integrated and end-to-end solution for ad hoc cloud computing environments. Ad hoc clouds harvest resources from existing sporadically available, non-exclusive (i.e. Primarily used for some other purpose) and unreliable infrastructures. In this paper we discuss the problems ad hoc cloud computing solves and outline our architecture which is based on BOINC.

The VERCE project has pioneered an e-Infrastructure to support researchers using established simulation codes on high-performance computers in conjunction with multiple sources of observational data. This is accessed and organised via the VERCE science gateway that makes it convenient for seismologists to use these resources from any location via the Internet. Their data handling is made flexible and scalable by two Python libraries, ObsPy and dispel4py and by data services delivered by ORFEUS and EUDAT. Provenance driven tools enable rapid exploration of results and of the relationships between data, which accelerates understanding and method improvement. These powerful facilities are integrated and draw on many other e-Infrastructures. This paper presents the motivation for building such systems, it reviews how solid-Earth scientists can make significant research progress using them and explains the architecture and mechanisms that make their construction and operation achievable. We conclude with a summary of the achievements to date and identify the crucial steps needed to extend the capabilities for seismologists, for solid-Earth scientists and for similar disciplines.

We present dispel4py a versatile data-intensive kit presented as a standard Python library. It empowers scientists to experiment and test ideas using their familiar rapid-prototyping environment. It delivers mappings to diverse computing infrastructures, including cloud technologies, HPC architectures and specialised data-intensive machines, to move seamlessly into production with large-scale data loads. The mappings are fully automated, so that the encoded data analyses and data handling are completely unchanged. The underpinning model is lightweight composition of fine-grained operations on data, coupled together by data streams that use the lowest cost technology available. These fine-grained workflows are locally interpreted during development and mapped to multiple nodes and systems such as MPI and Storm for production. We explain why such an approach is becoming more essential in order that data-driven research can innovate rapidly and exploit the growing wealth of data while adapting to current technical trends. We show how provenance management is provided to improve understanding and reproducibility, and how a registry supports consistency and sharing. Three application domains are reported and measurements on multiple infrastructures show the optimisations achieved. Finally we present the next steps to achieve scalability and performance.

The Grid and Cloud User Support Environment (gUSE) enables users convenient and easy access to grid and cloud infrastructures by providing a general purpose, workflow-oriented graphical user interface to create and run workflows on various Distributed Computing Infrastructures (DCIs). Its arrangements for creating and modifying existing workflows are, however, non-intuitive and cumbersome due to the technologies and architecture employed by gUSE. In this paper, we outline the first integrated web-based workflow editor for gUSE with the aim of improving the user experience for those with industrial data workflows and the wider gUSE community. We report initial assessments of the editor's utility based on users' feedback. We argue that combining access to diverse scalable resources with improved workflow creation tools is important for all big data applications and research infrastructures.

Earth scientist observe many facets of the planet's crust and integrate their resulting data to better understand the processes at work. We report on a new data-intensive science gateway designed to bring rock physicists and volcanologists into a collaborative framework that enables them to accelerate their research and integrate well with other Earth scientists. The science gateway supports three major functions: 1) sharing data from laboratories and observatories, experimental facilities and computational model runs, 2) sharing computational models and methods for analysing experimental and observational data, and 3) supporting recurrent tasks, such as data collection and running application in real time. Our prototype gateway has worked with two exemplar projects giving experience of data gathering, model sharing and data analysis. The geoscientists found that the gateway accelerated their work, triggered new practices and provided a good platform for long-term collaboration.

SUMMARY State‐of‐the‐art research in a variety of natural sciences depends heavily on methods of computational chemistry, for example, the calculation of the properties of materials, proteins, catalysts, and drugs. Applications providing such methods require a lot of expertise to handle their complexity and the usage of high‐performance computing. The MoSGrid (molecular simulation grid) infrastructure relieves this burden from scientists by providing a science gateway, which eases access to and usage of computational chemistry applications. One of its cornerstones is the molecular simulations markup language (MSML), an extension of the chemical markup language. MSML abstracts all chemical as well as computational aspects of simulations. An application and its results can be described with common semantics. Using such application, independent descriptions users can easily switch between different applications or compare them. This paper introduces MSML, its integration into a science gateway, and its usage for molecular dynamics, quantum chemistry, and protein docking. Copyright © 2013 John Wiley & Sons, Ltd.

The Berkeley Open Infrastructure for Network Computing (BOINC) is an open source client-server middleware system created to allow projects with large computational requirements, usually set in the scientific domain, to utilize a technically unlimited number of volunteer machines distributed over large physical distances. However various problems exist deploying applications over these heterogeneous machines using BOINC: applications must be ported to each machine architecture type, the project server must be trusted to supply authentic applications, applications that do not regularly checkpoint may lose execution progress upon volunteer machine termination and applications that have dependencies may find it difficult to run under BOINC. To solve such problems we introduce virtual BOINC, or V-BOINC, where virtual machines are used to run computations on volunteer machines. Application developers can then compile their applications on a single architecture, check pointing issues are solved through virtualization API's and many security concerns are addressed via the virtual machine's sandbox environment. In this paper we focus on outlining a unique approach on how virtualization can be introduced into BOINC and demonstrate that V-BOINC offers acceptable computational performance when compared to regular BOINC. Finally we show that applications with dependencies can easily run under V-BOINC in turn increasing the computational potential volunteer computing offers to the general public and project developers.

Server clustering is a common design principle employed by many organisations who require high availability, scalability and easier management of their infrastructure. Servers are typically clustered according to the service they provide whether it be the application(s) installed, the role of the server or server accessibility for example. In order to optimize performance, manage load and maintain availability, servers may migrate from one cluster group to another making it difficult for server monitoring tools to continuously monitor these dynamically changing groups. Server monitoring tools are usually statically configured and with any change of group membership requires manual reconfiguration, an unreasonable task to undertake on large-scale cloud infrastructures. In this paper we present the Cloudlet Control and Management System (C2MS), a system for monitoring and controlling dynamic groups of physical or virtual servers within cloud infrastructures. The C2MS extends Ganglia - an open source scalable system performance monitoring tool - by allowing system administrators to define, monitor and modify server groups without the need for server reconfiguration. In turn administrators can easily monitor group and individual server metrics on large-scale dynamic cloud infrastructures where roles of servers may change frequently. Furthermore, we complement group monitoring with a control element allowing administrator-specified actions to be performed over servers within service groups as well as introduce further customized monitoring metrics. This paper outlines the design, implementation and evaluation of the C2MS.

As more data-intensive computing applications are executed on high performance computing clusters, resource contention on the shared storage system attached to the clusters becomes significant. The contention might cause I/O performance degradation and spoil performance improvement of coordinated parallel I/O by the MPI-IO implementation. In order to solve this problem, an advanced reservation approach where storage resources are managed based on the reservations to satisfy the I/O performance requirements, has been proposed. In this paper, we apply the concept of reserved data access to MPI-IO, in particular to Two-Phase collective I/O which is primarily used for I/O aggregation in non-contiguous access by MPI applications. We developed a prototype by using Dynamic-CoMPI which supports further improvement of Two-Phase I/O by using a locality aware strategy, and Papio which is a parallel storage system providing performance reservation functionality. After describing our prototype design and implementation, we show leverage of the concept by comparing our implementation with other existing MPI-IO implementations backed by OrangeFS and Lustre. The evaluation experiment confirms that the optimization benefit of Two-Phase I/O can be preserved by our approach, under the resource contention situation.

Computer tomography (CT) perfusion imaging is widely used to calculate brain hemodynamic quantities such as cerebral blood flow, cerebral blood volume, and mean transit time that aid the diagnosis of acute stroke. Since perfusion source images contain more information than hemodynamic maps, good utilization of the source images can lead to better understanding than the hemodynamic maps alone. Correlation-coefficient tests are used in our approach to measure the similarity between healthy tissue time-concentration curves and unknown curves. This information is then used to differentiate penumbra and dead tissues from healthy tissues. The goal of the segmentation is to fully utilize information in the perfusion source images. Our method directly identifies suspected abnormal areas from perfusion source images and then delivers a suggested segmentation of healthy, penumbra, and dead tissue. This approach is designed to handle CT perfusion images, but it can also be used to detect lesion areas in magnetic resonance perfusion images.

Modern scientific collaborations have opened up the opportunity of solving complex problems that involve multi-disciplinary expertise and large-scale computational experiments. These experiments usually involve large amounts of data that are located in distributed data repositories running various software systems, and managed by different organisations. A common strategy to make the experiments more manageable is executing the processing steps as a workflow. In this paper, we look into the implementation of fine-grained data-flow between computational elements in a scientific workflow as streams. We model the distributed computation as a directed acyclic graph where the nodes represent the processing elements that incrementally implement specific subtasks. The processing elements are connected in a pipelined streaming manner, which allows task executions to overlap. We further optimise the execution by splitting pipelines across processes and by introducing extra parallel streams. We identify performance metrics and design a measurement tool to evaluate each enactment. We conducted experiments to evaluate our optimisation strategies with a real world problem in the Life Sciences---EURExpress-II. The paper presents our distributed data-handling model, the optimisation and instrumentation strategies and the evaluation experiments. We demonstrate linear speed up and argue that this use of data-streaming to enable both overlapped pipeline and parallelised enactment is a generally applicable optimisation strategy.

Within the context of the EU design study developmental gene expression map, we identify a set of challenges when facilitating collaborative research on early human embryo development. These challenges bring forth requirements, for which we have identified solutions and technology. We summarise our solutions and demonstrate how they integrate to form an e-infrastructure to support collaborative research in this area of developmental biology.

In modern distributed computing, vast amounts of data are stored in many different formats, employing different storage solutions. OGSA-DAI 3.0 is a middleware software solution. It provides application developers with the means to access data distributed across multiple platforms with different native access mechanisms. Data integration can take place at the server and deliver results using a variety of protocols and mechanisms within OGSA-DAI. It accomplishes this by using a highly flexible and extensible framework which can accommodate different types of data resources, such as XML databases, relational databases or files, different operations such as transformation to different formats, selection or filter operations. The framework can be extended by a developer to provide customized functionality for project specific tasks while using generic functions for common tasks such as database querying. This paper presents an overview of OGSA-DAI and how it tackles data access and integration through a set of example use cases.

The annual U.K. e-Science All Hands Meeting (AHM) is the premier e-Science conference held regularly in the United Kingdom.Supported mainly by the U.K. e-Science Core Programme, with sponsorship from the Joint Information Systems Committee and from industry, the AHM provides a forum for the e-Science community to present and demonstrate their research, exchange ideas and socialize.The AHM typically attracts approximately 600 participants from academia, industry and commerce, with a technical programme of keynote presentations, regular sessions, workshops, poster sessions and birds-of-a-feather meetings.The term 'e-Science' was first coined by Sir John Taylor, then Director General of the Research Councils, who said that 'e-Science is about global collaboration in key areas of science and the next generation of infrastructure that will enable it'.Such collaboration often takes place through the secure sharing of resources distributed across multiple partners, which has led Foster and Kesselmann to formulate the concept of the Virtual Organization.The Grid is a closely-related concept that refers to the distributed hardware, software and data that are often used to support collaboration.As the AHMs have developed, they have adopted a broad interpretation of what is meant by e-Science, and that is reflected in the papers selected for this special issue. CONTENTSThe third All Hands Meeting (AHM 2004), held 31 August-2 September 2004 at the East Midlands Conference Centre in Nottingham, featured 130 oral presentations spread across five workshops and 24 regular sessions.This special issue contains extended versions of selected papers from AHM 2004 with the aim of highlighting some of the most innovative and interesting research of the U.K. e-Science community.The papers cover a spectrum from fairly generic middleware to specific applications, although many of the papers report on how middleware is used to support a particular application (or class thereof).A good example of this latter type of paper is 'Developing LHCb Grid software:

Abstract Initially, Grid technologies were principally associated with supercomputer centres and large‐scale scientific applications in physics and astronomy. They are now increasingly seen as being relevant to many areas of e‐Science and e‐Business. The emergence of the Open Grid Services Architecture (OGSA), to complement the ongoing activity on Web Services standards, promises to provide a service‐based platform that can meet the needs of both business and scientific applications. Early Grid applications focused principally on the storage, replication and movement of file‐based data. Now the need for the full integration of database technologies with Grid middleware is widely recognized. Not only do many Grid applications already use databases for managing metadata, but increasingly many are associated with large databases of domain‐specific information (e.g. biological or astronomical data). This paper describes the design and implementation of OGSA‐DAI, a service‐based architecture for database access over the Grid. The approach involves the design of Grid Data Services that allow consumers to discover the properties of structured data stores and to access their contents. The initial focus has been on support for access to Relational and XML data, but the overall architecture has been designed to be extensible to accommodate different storage paradigms. The paper describes and motivates the design decisions that have been taken, and illustrates how the approach supports a range of application scenarios. The OGSA‐DAI software is freely available from http://www.ogsadai.org.uk . Copyright © 2005 John Wiley & Sons, Ltd.

Abstract The U.K. e‐Science Programme is a £250 million, five‐year initiative which has funded over 100 projects. These application‐led projects are underpinned by an emerging set of core middleware services that allow the coordinated, collaborative use of distributed resources. This set of middleware services runs on top of the research network and beneath the applications we call the ‘Grid’. Grid middleware is currently in transition from pre‐Web Service versions to a new version based on Web Services. Unfortunately, only a very basic set of Web Services embodied in the Web Services Interoperability proposal, WS‐I, are agreed by most IT companies. IBM and others have submitted proposals for Web Services for Grids—the Web Services ResourceFramework and Web Services Notification specifications—to the OASIS organization for standardization. This process could take up to 12 months from March 2004 and the specifications are subject to debate and potentially significant changes. Since several significant U.K. e‐Science projects come to an end before the end of this process, the U.K. needs to develop a strategy that will protect the U.K.'s investment in Grid middleware by informing the Open Middleware Infrastructure Institute's (OMII) roadmap and U.K. middleware repository in Southampton. This paper sets out an evolutionary roadmap that will allow us to capture generic middleware components from projects in a form that will facilitate migration or interoperability with the emerging Grid Web Services standards and with ongoing OGSA developments. In this paper we therefore define a set of Web Services specifications, which we call ‘WS‐I+’ to reflect the fact that this is a larger set than currently accepted by WS‐I, that we believe will enable us to achieve the twin goals of capturing these components and facilitating migration to future standards. We believe that the extra Web Services specifications we have included in WS‐I+ are both helpful in building e‐Science Grids and likely to be widely accepted. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract This paper describes the evolution of the design and implementation of a distributed run‐time system that itself is designed to support the evolution of the topology and implementation of an executing, distributed system. The three different versions of the run‐time architecture that have been designed and implemented are presented, together with how each architecture addresses the problems of topological and functional evolution. In addition, the reasons for the rapid evolution of the design and implementation of the architecture are also described. From the lessons learned in both evolving the design of the architecture and in trying to provide a run‐time system that can support run‐time evolution, this paper discusses two generally applicable observations: evolution happens all the time, and it is not possible to anticipate how systems will evolve as designs; and large, run‐time systems do not follow a predictable path. In addition to this, rapid prototyping has proved to be extremely useful in the production of the three architectures; this kind of prototyping has been made much easier by designing the core set of Java abstractions in terms of interfaces; and building an architecture that allows as many decisions as possible to be made at run‐time which has produced a support system that is more responsive to the user as well as the distributed environment in which it is executing. Copyright © 2003 John Wiley & Sons, Ltd.

Abstract We report on a bulk object‐loading algorithm for persistent object stores calledGhosted Allocation. It allocates large numbers of objects in a persistent store atomically, efficiently, and reliably. Its main strengths are that it minimizes I/O traffic, optimizes the disk access pattern, and does not impose complex requirements on applications. Our experiments demonstrate that theGhosted Allocationalgorithm is efficient and most importantly scalable, sustaining allocation rates of up to 63 000 objects s‐1. Copyright © 2001 John Wiley & Sons, Ltd.

Recent HCI research has produced analytic evaluation techniques which claim to predict potential usability problems for an interactive system.Validation of these methods has involved matching predicted problems against usability problems found during empirical user testing. This paper shows that the matching of predicted and actual problems requires careful attention, and that current approaches lack rigour or generality. Requirements for more rigorous and general matching procedures are presented. A solution to one key requirement is presented: a new report structure for usability problems.It is designed to improve the quality of matches made between usability problems found during empirical user testing and problems predicted by analytic methods. The use of this report format is placed within its design research context, an ongoing project on domain-specific methods for software visualizations.

As application systems live longer and grow in size and complexity, there is an ever increasing need for methods and tools that can support software builders in constructing maintainable, well-structured and consistent systems. This paper describes the notion of software constraints as an aid to developing such systems. Software constraints make rules and conventions commonly agreed to in a given programming environment explicit and automatically checkable. The potential usefulness of software constraints was investigated in both industrial and research environments. A framework for categorization of such constraints is defined. Constraints are proposed that are generally applicable and others that are tightly connected to and support a certain programming method. Tools for automatic checking are crucial if software constraints are to be used. An architecture for such tools and two realizations are described.

A challenging issue in the construction and maintenance of large application systems is how to determine which components need to be rebuilt after change, when and in which order. Rebuilding is typically recompilation and linking, but may also include update of derivable components such as cross-reference databases and re-creation of library indexes. Type definitions or schema, and data values in a file store, database or persistent store may also need to be rebuilt. The main purpose of this paper is to describe how persistent language technology can be exploited to enhance build management. In particular, the paper describes a method for transactional, incremental linking and the implementation of its support. To help implement this method, and to make it safer and more efficient to carry out rebuild activities in general, we have defined a set of automatically checkable constraints on the software. The build management tool we have implemented, the Builder, derives rebuild dependencies automatically and offers partitioning of dependency graphs—a means to defer or avoid unnecessary rebuilding. The Builder is implemented in a persistent programming language and provides build management for applications written in the language. It exploits features such as strong typing, runtime linguistic reflection, and referential integrity provided by the language processing technology. The Builder operates over both programs and (complex) data, which is in contrast to conventional language-centred tools. © 1997 by John Wiley & Sons, Ltd.

Current RPC mechanisms for persistent languages are either pass by reference-in which case they do not scale-or pass by copy-in which case they duplicate objects and destroy sharing relationships. In this paper we argue that to build very large distributed persistent applications a compromise between these two mechanisms is needed. The ultimate goal of our research is to build a scalable persistent RPC while still maintaining object sharing type safety, type completeness and semantics that are readily understood by application programmers.

Handling exceptional circumstances is frequently the reason why an elegant and expressive algorithm becomes obscure and verbose when transcribed into a programming language. This paper reviews the exception handling facilities of existing languages and uses these to illustrate the factors influencing the design of the exception handling facilities in PS-algol. These facilities eventually materialised in the notions of system events and programmer exceptions. A description is given of event and exception handling in PS-algol.

Static binding and type-checking, by which we mean the ability to bind names and assign types in advance of program execution is a desirable feature of many modern programming languages. In particular, it is one of the most useful techniques for catching programming errors and is a powerful aid in program optimisation, However, many programming tasks, especially those involving persistent data, appear to require some form of delayed binding and type checking. In this paper we illustrate the need for delaying those operations and examine a selection of languages to see how they provide a mixture of delayed and static operations. We conclude that, with the current state of language technology, the programmer needs explicit control over the timing of binding and type checking.

Abstract A number of data models have been proposed in the literature to improve the usability of database systems. Most of these proposals have not been implemented. It is felt that a working implementation is a necessary prerequisite for a serious study of these proposals. So far, implementing data models has been a daunting task, requiring a large team. We report here on a simple implementation technique using the persistent algorithmic language. PS‐algol, which promises to make the task of implementing data models a manageable one. The feasibility of the approach is demonstrated by implementing an entity‐based functional data model (extended function data model) using PS‐algol.

In order to represent inheritance, several recent designs for database programming languages have made use of class construct, which can be thought of as a restricted data type with an associated set of instances. Moreover, these classes are persistent they survive from one program invocation to another. This paper examines whether it is necessary to the together type, extent and persistence in order to model inheritance and suggests that they may be separated to provide more general database programming languages. In particular we shall see that it is possible to assign a generic data type to a function that extracts all the objects of a given type in the database so that the class hierarchy can be derived from the type hierarchy. We shall also examine object-level inheritance and its relationship to data types for relational databases. A final section examines how the various forms of persistence interact with inheritance at both object and type level.

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.

This paper reports on an implementation of the functional data model and the associated data language. The notable features of the data model underlying the implementation include its object orientation, use of the extended function concept to model both attributes and relationships, hierarchically organised entity types with property inheritance, and the specification of derived functions which are used to infer automatically the data implied from that held explicitly in the database. The implementation provides an interactive user interface that supports a high-level set-based query and update language. Facilities for defining and using named views are provided. Meta data is made part of the database so that it can be examined using the data language. The implementation is done using the persistent algorithmic language PS-Algol.

A persistent programming environment, together with a language that supports first class procedures, may be used to provide the semantic features of other object modeling languages. In particular, the two concepts may be combined to implement abstract data types, modules, separate compilation, views, and data protection. Furthermore, the ideas may be used in system construction and version control, as demonstrated here.

Abstract This is a description of the integrated Persistent Object Management System (POMS) for the language PS‐algol. The objective of POMS is to provide an implementation of the PS‐algol persistent heap1 entirely by means of procedures written in PS‐algol.

This paper presents the identification of a new programming language concept and reports our initial investigations of its utility. The concept is to identify persistence as an orthogonal property of data, independent of data type and the way in which data is manipulated. This is expressed by the principle that all data objects, independent of their data type, should have the same rights to persistence or transience. We expect to achieve persistent independent programming, so that the same code is applicable to data of any persistence. We have designed a language PS-algol by using these ideas and constructed a number of implementations. The experience gained is reported here, as a step in the task of achieving languages with proper accommodation for persistent programming.

Abstract The chunk manager provides simple transaction management, concurrency control and allocates, administers and retrieves apparently contiguous chunks of data of arbitrary and varying size on disc. This system is designed to permit students and research workers to rapidly assemble and test their own DBMS, supporting any data model. Currently it is being used to support PS‐Algol, an implementation of DAPLEX, a relational system and student database exercises. A chunk is similar to the common meaning of ‘record’ except that there is no implication of internal structure or consistent and static size. An efficient table processing capability is also provided. Locking and access control are implemented at the bag level to prevent conflicting use of data without excessive operating cost. The problems associated with concurrent access of shared bags have been studied and the currently implemented and future proposed solutions are discussed.

Abstract PS‐Algol is a dialect of Algol for the programming of problems that would normally require a database management system. It supports a persistent heap, and an associative store; it has embedded within the language features to support tasks normally carried out by filing systems or database management systems.

Abstract The essential components of an effective program development environment are described. These assist in the interactive investigation of program behaviour and accelerate the rate at which programs are modified. The whole system is compact and simple, being designed for use on small machines. It is considered as important to understand how to use these tools as it is to provide them.

Abstract A Low‐level data language, IDL, is presented as a machine‐independent medium for representing data structures. It is used to transfer structures generated by SLP, a compact list processing language, across the boundaries imposed by differing machines, operating systems and languages. Translation overheads are minimized and use of the language reduces data and machine dependence in programs. Translation algorithms and their performance statistics are presented. The use of the representation for the formation and manipulation of libraries of data structures in demonstrated.

At the University of Cambridge Computer Laboratory experiments are proceeding in the design of an integrated computer-aided circuit design system (Cheney et al., 1971). We discuss here the search for a method of reliably obtaining the time response of a circuit when the frequency response is available.