A comparative study of structured and un-structured remote data access in distributed computing systems

Recently, the use of distributed computing systems has been growing rapidly due to the result of cheap and advanced microelectronic technology. In addition to the decrease in hardware costs, the tremendous development in machine to machine communication interfaces, especially in local area networking, also favours the use of distributed systems. Distributed systems often require remote access to data stored at different sites. Generally, two models of access to remote data storage exist: the un structured and structured models. In the former, data is simply stored as row of bytes, whereas in the latter, data is stored along with the associated access codes. The objective of this thesis is to compare these two models and hence determines the tradeoffs of each model. First of all, an extended review of the field of distributed data access is provided which addressing key issues such as the basic design principles of distributed computing systems, the notions of abstract data types, data inheritance, data type system and data persistence. Secondly, a distributed system is implemented using the persistent programming language PS-algol and the high level language C in conjunction with the remote procedure call facilities available in Unix(^1) 4.2 BSD operating system. This distributed system makes extensive use of Unix's software tools and hence it is called DCSUNIX for Distributed Computing System on UNIX. Thirdly, two specific applications which employ the implemented system will be given so that a comparison can be made between the two remote data access models mentioned above. Finally, the implemented system is compared with the criteria established earlier in the thesis. keywords: abstract data types, class, database management, data persistence, information hiding, inheritance, object oriented programming, programming languages, remote procedure calls, transparency, and type checking

On the Utilisation of Persistent Programming Environments

There is a growing gap between the supply and demand of good quality software, which is primarily due to the difficulty of the programming task and the poor level of support for programmers. Programming is carried out using software tools which do not match very well either real world understanding of a problem or even the other tools which need to be used. In every phase of software production, the programmer must master new tools which function in a different way from each other. The Persistent Programming Paradigm attempts to reduce these problems by providing a programming environment which gives consistent methods of accessing program values of various kinds. Long-term and short-term data are treated in the same way. Numbers, text, graphical values and even program objects are all referred to in the same consistent way. Languages which support persistence provide considerable power within a simple environment, so that programmers can perform most if not all parts of the programming task in a coherent and uniform manner. This thesis tests the hypothesis that programmers do in fact derive some benefit from this - the simplification of the program and faster implementation of complex programs. The persistent language PS-algol is introduced and used to build: user-interface and compiler tools; a database application; some data modelling tools, both relational and semantic; a rapid prototyping system; an object-oriented language; and software support systems. In doing so, the thesis demonstrates the breadth of work which can be achieved using a Persistent Programming Language, and the ease with which these various projects can be implemented. Further, the thesis derives the beginnings of a methodology for using such a language and analyses how PS-algol could be improved. In doing so, the work aims to put the Persistent Programming Paradigm on a firm basis following significant use and experimentation

On the construction of persistent programming environments

This thesis presents research into the construction of persistent programming systems. Much of the thesis is concerned with the design and implementation of persistent programming languages, in particular PS-algol and Napier. Both languages support machine independent vector and raster graphics data types. Napier provides an environment mechanism that enables the incremental construction and binding of programs. Napier has a powerful type system featuring parametric polymorphism and abstract data types. The machine supporting Napier, the Persistent Abstract Machine, is investigated. The machine supports an efficient implementation of parametric polymorphism and abstract data types. The Persistent Abstract Machine has a layered architecture in which permits experimentation into language implementation and store design. The construction of compilers in a persistent environment is explored. A flexible compiler architecture is developed. With it, a family of compilers may be constructed at relatively little cost. One such compiler is the callable compiler; this is a first class data object in the persistent environment. The uses of such a compiler are explored, in particular in the construction of an object browser. The persistent object browser introduces a new software architecture that permits adaptive programs to be constructed incrementally. This is achieved by writing, compiling and linking new procedures into an executing program. The architecture has been successfully applied to the construction of adaptive databases and bootstrap compilers

The Design and Implementation of a Prototype Geographic Information System Using a Novel Architecture Based on PS-Algol

This thesis is concerned with the design and implementation of a novel architecture for a geographic information system based on the use of a new database language called PS-algol, in conjunction with a hybrid database structure. The main aspects discussed within the context of this thesis are:- i) the definition of a database; ii) the components and functions of a database management system; iii) the features of PS-algol; iv) the new system architecture; v) the use of operational management system; vi) data entry as carried out by the system; vii) the facility for the cartographic representation of features; viii) data retrieval and its potential use; and ix) the generation of hard-copy output The thesis also includes a review of existing geographical information systems against which the novelty of the new approach can be judged

Abstract machine design for increasingly more powerful ALGOL-languages

This thesis presents the work and results of an investigation into language implementation. Some work on language design has also been undertaken. Three languages have been implemented which may be described as members of the Algol family with features and constructs typical of that family. These include block structure, nested routines, variables, and dynamic allocation of data structures such as vectors and user-defined structures. The underlying technique behind these Implementations has been that of abstract machine modelling. For each language an abstract intermediate code has been designed. Unlike other such codes we have raised the level of abstraction so that the code lies closer to the language than that of the real machine on which the language may be implemented. Each successive language is more powerful than the previous by the addition of constructs which were felt to be useful. These were routines as assignable values, dynamically initialised constant locations, types as assignable values and lists. The three languages were, Algol R a "typical" Algol based on Algol W h an Algol with routines as assignable values, enumerated types, restriction of pointers to sets of user-defined structures, and constant locations. nsl a polymorphic Algol with types as assignable values, routines as assignable values, lists, and type- and value-constant locations. The intermediate code for Algol R was based on an existing abstract machine. The code level was raised and designed so that it should be used as the input to a code generator. Such a code generator was written improving a technique called simulated evaluation. The language h was designed and a recursive descent compiler written for it which produced an intermediate code similar in level to the previous one. Again a simulated evaluation code generator was written, this time generating code for an interpreted abstract machine which implemented routines as assignable and storable values. Finally the language nsl was designed. The compiler for it produced code for an orthogonal, very high level tagged architecture abstract machine which was implemented by interpretation. This machine implemented polymorphism, assignable routine values and type- and value- constancy. Descriptions of the intermediate codes/abstract machines are given in appendices

Reports to the President

A compilation of annual reports for the 1989-1990 academic year, including a report from the President of the Massachusetts Institute of Technology, as well as reports from the academic and administrative units of the Institute. The reports outline the year's goals, accomplishments, honors and awards, and future plans