Steven Atkinson's Publications Page

Abstract: The reuse of complete software developments and the processes used to create them has the potential to significantly ease the process of software engineering, by providing a source of verified software artefacts.

Software libraries are collections of software artefacts which have been aggregated to form a resource-rich environment, from which software engineers can reuse the efforts of others during subsequent software development. By storing such information, software libraries serve as a vehicle for the exchange of ideas and experience between software engineers.

It is argued that reuse of software artefacts can be achieved through the utilisation of software libraries. However, software library systems are not yet common or mature phenomena, and as such are themselves candidates for software engineering analysis.

The goal of this thesis is to provide a reasoned formal specification of a software library system, to serve as a precise, clear context in which to analyse and discuss general software library structures and processes. This yields a formal basis for the continuing development of software library designs and implementations, promoting the development of new reuse-oriented software engineering techniques.

Through formalisation of software libraries, deficiencies of existing software libraries are identified, suggesting new ways of modelling library artefacts and operations. As the new models are developed, processes for formulating library policies are proposed. A library of object-oriented class declarations is also developed to serve as an illustration of the new models and processes.

Ultimately, the formal specifications and processes gathered together in this thesis form a coherent description of software library systems. This promotes the effective reuse of software artefacts by providing a more formal structure for their storage and dissemination.

Abstract: If the role of software libraries is to communicate information about software artefacts between software engineers, it is vital that the information be stored in such a manner as to be readily understandable. The designs of existing software libraries present several cognitive impediments to a software engineer, hindering the understanding of library organisation and content. In this paper, a focused review of existing software libraries is undertaken. Shortcomings of the designs of existing software libraries and resulting cognitive deficiencies are identified. The design problems to be discussed are: the hiding of underlying library structure, the inadequacy of component interfaces, the problems of querying large collections, and the subjective nature of component organisation. Having encountered these problems with existing software libraries, some avenues for alleviating them are identified.

Abstract: The challenge of software reuse is to record software development knowledge in such a way that it is readily stored digitally and easily retrieved, understood and used by other software engineers. Hence at the highest level, the process of retrieval from a repository is to take a description of a problem, and search for stored knowledge which may help to solve the described problem. The purpose of component retrieval is therefore concerned with finding component behaviours which solve a problem described by a query. Most proposed component retrieval schemes simulate this search for desired behaviour, either by using text-based, vocabulary classification, structural matching or specification matching techniques. Of course, most retrieval schemes also consider contextual aspects, such as resource usage, efficiency and internal representation. A theoretical definition of behavioural retrieval is required to describe the ideal (modulo contextual aspects) retrieval scheme, despite its probable inefficiency in practice. In this paper a theoretical definition of behavioural retrieval is outlined, showing that useful, exploitable structure does exist in behaviour.

Abstract: The central problem associated with libraries of object-oriented software components is that of retrieval: how to find in the library those components that can be used in the construction of a particular application. Approaches to this problem can be classified into three categories based upon the way components are represented: external classification, structural matching and behavioural. The aim of the research described in this paper is to unify these existing approaches to the component retrieval problem into a formally specified object-oriented framework, providing a model enabling comparison and description of integrated retrieval schemes.

Abstract: The reuse of complete software developments and the processes used to create them has the potential to significantly ease the process of software engineering, by providing a source of verified software artifacts. It is suggested that reuse of software artifacts can be achieved through the utilization of software libraries. However, software library systems are not yet common or mature phenomena, and as such are themselves candidates for the application of requirements analysis, formal specification, design and other software engineering activities. A more formal approach to the analysis of software library requirements and their specification will provide a basis for the development of useful software libraries.

Abstract: The central problem associated with libraries of reusable software components is that of retrieval: how to find in the library those components that can be used in the construction of a particular application. There have been three major proposed solutions to this problem: faceted (classification), signature-matching (structural) and behavioural (functional) retrieval. The aim of this paper is to unify these existing approaches to the component retrieval problem into a formally specified framework, providing a model upon which meaningful comparisons are made and principles formulated.

Abstract: The Proposed Eiffel Library Kernel Standard has been created for the purpose of promoting multi-platform interoperability using the Eiffel language. It consists of a set of twenty class specifications, called the library kernel, which serve as a benchmark against which proposed library implementations can be tested for compatibility with the standard. The rules for kernel compatibility should be clear and unambiguous in order to ensure that the interoperability sought is not compromised. A formal specification language offers the precision and degree of confidence required. This paper presents a model of the Proposed Eiffel Library Kernel Standard in the formal specification language Object-Z, which has been advocated for the specification of standards.

Abstract: The central problem associated with libraries of reusable software components such as classes is that of retrieval: how to find in the library those classes that can be used in the construction of a particular application. At the heart of class retrieval is the issue of behaviour: to decide if a library class is appropriate for a particular application it is necessary to know how objects of that class behave, i.e. how they react when sent messages by their environment. In this paper a methodology for searching libraries to find classes whose objects behave in some specified manner is defined. In general, it will not be possible to find a class whose objects behave exactly as required. In this case the methodology finds classes whose objects best approximate the specified behaviour in a precisely defined sense. The aim is to retrieve classes that can be easily modified to define objects that behave exactly as required.

Abstract: Researchers in the field of software re-engineering have recognised that transformations acting upon the abstract syntax trees of source programs are a useful method of preserving the semantics of program constructs whilst changing the language in which they are expressed. Software re-engineering environments will therefore require infrastructure support for storing abstract syntax trees. This report describes the development of an open architecture object store system which provides this support, and then demonstrates how the openness of the system allows communication of abstract syntax structures between the system and multiple external languages.