Paul Philbrow

Type-Safe Linguistic Reflection: A Generator Technology

Reflective systems allow their own structures to be altered from within. In a programming system reflection can occur in two ways: by a program altering its own interpretation or by it changing itself. Reflection has been used to facilitate the production and evolution of data and programs in database and programming language systems. This paper is concerned with a particular style of reflection, called linguistic reflection, used in compiled, strongly typed languages. Two major techniques for this have evolved: compile-time reflection and run-time reflection. These techniques are described together with a definition and anatomy of reflective systems using them. Two illustrative examples are given and the uses of type-safe reflective techniques in a database programming language context are surveyed. These include attaining high levels of genericity, accommodating changes in systems, implementing data models, optimising implementations and validating specifications.

Exploiting persistence in build management

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.

The persistent workshop - a programming environment for Napier88

The Persistent Workshop is a programming environment to support the construction of application systems in Napier88, a persistent programming language. In addition to supporting programming activities, the Workshop provides a demonstration of the persistence technology together with an environment in which various experiments can be conducted. The paper gives a brief description of the underlying principles of persistence, which are exploited by the Workshop. The basic structure of the Workshop is described, together with a brief summary of the tools provided within the programming environment, followed by an outline of the internal structure of the Workshop and the use of persistent data structures. Some initial measurements on the usage of the Workshop are briefly presented, and we discuss related work. Finally, the current status of the Workshop is described together with some comments on future work.

The Glasgow Persistent Libraries

This chapter describes the development of the Glasgow Persistent Libraries for Napier88. Our overall goals are to increase software re-use and accelerate software construction and maintenance. The objectives of this work were to investigate the creation of high-quality library components and the provision of accurate retrieval mechanisms enabling users to find relevant library components. We discuss the basic principles which guided our research and describe the tools which were built to support the construction and use of the Libraries. To conclude, we outline possible future work in the area of large component libraries.

PS-Algol's device-independent output statement

We describe a language-level approach to device-independent output. The paper moves from an abstract discussion through to the provision of destinations for PS-algols print statement. Some feedback from programmers is presented, and conclusions drawn.