Land information systems : an overview and outline of software requirements

This thesis looks at some aspects of land information systems. The introduction gives the rationale for this study, and the second chapter outlines the development of land information systems with particular reference to the cadastre. In the third chapter the software requirements for the development of land information systems are considered. Programming language and databases are discussed. The fouth chapter deals with the organisation and hardware needed for a land information system. Finally, in the fifth chapter some of the algorithms used in land information systems are presented. Four appendices cover the programmes which were developed in the course of this study, the software specification for an operational system, an example of LIS-related data in a large organisation, and the syntax of Modula-2, the programming language used for the examples

Concurrency in modula-2

A concurrent program is one in which a number of processes are considered to be active simultaneously . It is possib l e to t hink of a process as being a separate sequential program executing independently of other processes, although perhaps communicating with them at desired pOints . The concurrent program, as a whole, can be executed in one of two ways: il ii) in true concurrent manner, wi th each process executing on a dedicated processor in a quasi - concurrent manner, where a processor's processes . time is multiplexed between single the There are two motivations for the study of concurrency in programming languages : i) concurrent programming facilities can be exploited in systems where one has more t han one processor . As technology i mproves, machines having multiple processors will proliferate ii) concurrent p r ogramming facilities may allow programs to be structured as independent , bu t co - operating, processes which can then be implemented on a single processor system . This structure may be more natural to the programmer then the traditional sequential structures. An example is provided by Conway's - 1- Clearly, languages Pascal) problem [Ben82] . by their very nature, traditional sequential- type (Fortran, Basic, Cobol and earlier versions of prove inadequate for the purposes of concurrent programming without considerable extension (which some manufacturers have provided, rendering their compilers non standard-conforming). The general convenience of high level languages provides strong motivation for their development for rea l time programming. Modula - 2 [Wir83] is but one of a number of such r ecently developed languages, designed not only to fulfil a "sequential" role but also to offer facilities for concurrent programming. Developed by Niklaus Wirth in 1979 as a successor to Pascal and Modula, it is intended to serve under the banner of a generalpurpose systems - implementation language. This thesis investigates concurrency i n Modula - 2 and takes the following form: i ) an analYSis of the concurrent facilities offered ii) problems and difficulties associated with these facilities iii) improveme nts and enhancements, including the feasibility of using Modula - 2 to simulate constructs found in other languages, such as the Hoare monitor [Hoa74] and the Ada rendezvous [Uni81]. - 2- Each section concludes with an appraisal of the work conducted in that section . The final section consists of a critical assessment of those Modula - 2 language constructs and facilities provided for the implementation of concurrency and a brief look at concurrency in Modula, Modula-2's predecessor. - Introduction.KMBT_363Adobe Acrobat 9.53 Paper Capture Plug-i

UKC ANSAware Survival Guide (for Modula-3)

The ANSAware platform is a suite of libraries and tools which facilitate the building of distributed applications. The documentation with the release forms little more that a reference manual to the language and does not aid the first time user. This document provides a simple introduction to distributed systems concepts and, through the use of an example, demonstrates how to build applications with ANSAware

Modula-2*: An extension of Modula-2 for highly parallel programs

Parallel programs should be machine-independent, i.e., independent of properties that are likely to differ from one parallel computer to the next. Extensions are described of Modula-2 for writing highly parallel, portable programs meeting these requirements. The extensions are: synchronous and asynchronous forms of forall statement; and control of the allocation of data to processors. Sample programs written with the extensions demonstrate the clarity of parallel programs when machine-dependent details are omitted. The principles of efficiently implementing the extensions on SIMD, MIMD, and MSIMD machines are discussed. The extensions are small enough to be integrated easily into other imperative languages

Fast Recompilation of Object Oriented Modules

Once a program file is modified, the recompilation time should be minimized, without sacrificing execution speed or high level object oriented features. The recompilation time is often a problem for the large graphical interactive distributed applications tackled by modern OO languages. A compilation server and fast code generator were developed and integrated with the SRC Modula-3 compiler and Linux ELF dynamic linker. The resulting compilation and recompilation speedups are impressive. The impact of different language features, processor speed, and application size are discussed

Parallel Programming Using Shared Objects and Broadcasting

The two major design approaches taken to build distributed and parallel computer systems, multiprocessing and multicomputing, are discussed. A model that combines the best properties of both multiprocessor and multicomputer systems, easy-to-build hardware, and a conceptually simple programming model is presented. Using this model, a programmer defines and invokes operations on shared objects, the runtime system handles reads and writes on these objects, and the reliable broadcast layer implements indivisible updates to objects using the sequencing protocol. The resulting system is easy to program, easy to build, and has acceptable performance on problems with a moderate grain size in which reads are much more common than writes. Orca, a procedural language whose sequential constructs are roughly similar to languages like C or Modula 2 but which also supports parallel processes and shared objects and has been used to develop applications for the prototype system, is described