Chris Sadler

Managing the Evolution of .NET Programs

The component-based model of code execution imposes some requirements on the software components themselves, and at the same time lays some constraints on the modern run-time environment. Software components need to store descriptive metadata, and the run-time system must access this ‘reflectively’ in order to implement dynamic linking. Software components also undergo dynamic evolution whereby a client component experiences the effects of modifications, made to a service component even though these occurred after the client was built.

Evolution of Distributed Java Programs

A major challenge of maintaining object-oriented programs is to find a means of evolving software that already has a distributed client base. This should be easier for Java developers than for most, because dynamic linking has been designed into the runtime system.It turns out however that things are not so straightforward as they seem, since a given modification can leave a remote client in one of a number of states, not all of which are tolerable, let alone desirable. In this paper we attempt to delineate these states, and to consider ways of avoiding the worst of them. We describe our utility, which offers library developers a transparent version control system, to protect their remote clients.

Component adaptation in contemporary execution environments

Because they are required to support component deployment and composition, modern execution environments embody a number of common features such as dynamic linking and support for multiple component versions. These features help to overcome some classical maintenance problems focused largely on component evolution, where successive generations of collaborating components need to be kept collaborating. What has been less studied has been component adaptation, whereby a component developed in an environment consisting of one set of service components is required to operate in one or several other environments containing qualitatively different components. In this paper we examine the needs developers and deployers have arising out of component adaptation and explore the concept of Flexible Dynamic Linking as a means of satisfying them. We describe a suite of tools developed to demonstrate this approach to component adaptation support within the .NET Common Language Runtime.

Keeping control of reusable components.

Development and deployment via components offers the possibility of prolific software reuse. However, to achieve this potential in a component-rich environment, it is necessary to recognize that component deployment (and subsequent composition) is closer to a continual process than a one-off operation. This is due to the requirement that newly-evolved components need to replace their ancestors in a timely and efficient manner at the client deployment sites. Modern runtime systems which employ dynamic link-loading mechanisms can permit such dynamic evolution. We review the capabilities of several alternative runtime environments to establish some requirements for dynamic evolution. Then we describe a tool designed to support developers and administrators in the migration of component updates within the Microsoft .NET framework.

Ephemeral Java source code

In an object oriented, distributed environment, program maintenance, which has never been the most predictable task, becomes even more uncertain. Javas dynamic loading mechanism was developed to tackle some of the uncertainties. In doing so, it shifts the focus from the state of the sources to that of the binaries. This paper discusses some of the implications of that move.

Reuse and Abuse

Over a number of years we examined the problem of dynamic evolution from the viewpoints of language design and runtime support. We developed client-side and server-side tools to supplement component runtime systems. In this paper we crystallized the major features of the problem, and critically evaluated our contribution against other solutions to this and allied problems, such as component adaptation and dynamic update. With the recent incorporation of a type forwarding facility, Microsofts system architects claim to have finally designed this problem out of .NET – the first runtime system to evade the major obstacles the tools were designed to overcome.

SELECTING MICROCOMPUTERS FOR SCHOOLS

Abstract This paper attempts to address the problem of selecting a suitable microcomputer for use in schools. After analysing the different sorts of activity in which one might apply microcomputers either as an alternative to other teaching tools or as an essential or unique feature in a classroom application, the paper deals with some criteria for matching available systems to specific applications. In conclusion, the direction of the main thrust of U.K. government policy in the field of schools microcomputing is assessed in the light of these and other criteria.

Functional progaming on parallel architectures

Publisher Summary This chapter elaborates the functional programming on parallel architectures. Executable specification languages are very high-level languages, and executable specifications display all the characteristics of high-level language programs. They offer greatly reduced source-code length. It is found that if a PASCAL program offers an order-of-magnitude reduction in length over an equivalent assembler program, a typical executable specification probably offers a further order-of-magnitude reduction. One effect of this is a marked improvement in programmer efficiency, since individual programmers are thought to deliver roughly the same number of lines of code per unit time regardless of the language they use. On the negative side, high-level language programs make notoriously less efficient use of the underlying hardware than equivalent machine-code programs, and this is correspondingly truer for executable specifications. Hardware developments resulting in processor speed improvements and the lowering costs of logic circuits have broadly managed to compensate for the time, and space overheads of conventional high-level language programs.

Parallel architecture for functional programming

Abstract Modern software development seeks to produce faster, more reliable programs. Greater speed comes from putting more mips into the machine while one approach to improving reliability lies in trying to introduce greater rigour into the design process. Using a conventional architecture and with a traditional programming language these two goals are in conflict as the extra power is soaked up by the more elaborate code. Happily the conflict can be resolved by recourse to a functional language which allows for parallel execution through the mechanism of graph reduction. This paper introduces a representative functional programming language, Hope, and explores the ALICE architecture which executes Hope programs in parallel.