A study of the use of abstract types for the representation of engineering units in integration and test applications

Physical quantities using various units of measurement can be well represented in Ada by the use of abstract types. Computation involving these quantities (electric potential, mass, volume) can also automatically invoke the computation and checking of some of the implicitly associable attributes of measurements. Quantities can be held internally in SI units, transparently to the user, with automatic conversion. Through dimensional analysis, the type of the derived quantity resulting from a computation is known, thereby allowing dynamic checks of the equations used. The impact of the possible implementation of these techniques in integration and test applications is discussed. The overhead of computing and transporting measurement attributes is weighed against the advantages gained by their use. The construction of a run time interpreter using physical quantities in equations can be aided by the dynamic equation checks provided by dimensional analysis. The effects of high levels of abstraction on the generation and maintenance of software used in integration and test applications are also discussed

Control abstraction in parallel programming languages

Control abstraction is the process by which programmers define new control constructs by specifying an ordering of statement execution. Using control abstraction, we can create new control constructs for parallel programming, separate the specification of parallelism and synchronization from the rest of the application code, and vary the parallelism exploited during execution by selecting alternative implementations of control constructs. This paper argues for the inclusion of control abstraction in parallel programming languages by demonstrating that the benefits of control abstraction far outweigh the costs. We present a notation for precisely defining the meaning of a parallel control construct; and use that notation in the definition a small set of primitive mechanisms for parallel programming with control abstraction. We show how to define and implement new parallel control constructs using these primitive mechanisms, and provide examples of application-specific control constructs used in real programs . Finally, we describe techniques that can be used to implement a parallel programming language based on control abstraction, and demonstrate the efficiency of those techniques in an implementation on the BBN Butterfly multiprocessor .Keywords: parallel programming languages, control abstraction, architectural adaptability, closures, early reply, Matroshk

Development of an Object-Oriented High-Level Language and Construction of an Associated Object-Oriented Compiler

Computerized automation has long past been in practice, and engineers are developing ways and means of improving strategies to achieve better performance. Related search is concentrated on developing methords to diversify the application of computing technologies by bringing software and its field of application close together. The idea is to eventually create a software configuration that makes itself transparent to the user by mapping reality onto the computer's monitor. This paper is a report on a portion of and interdisciplinary project that attempts to apply state-of-the-art software techniques in the design of an integrated programming environment for manufacturing purposes. The portion of the project described in this paper is concerned with two aspects: designing a special purpose object-oriented high-level language for programming a classroom research laboratory for manufacturing students and faculty, and designing and implementing an object-oriented compiler to allow students to write programs using this language. The purpose of the project is to integrate manufacturing devices and cells with the existing computer network to provide a flexible manufacturing system

Proposals for enhancement of the Ada programming language:a software engineering perspective

This thesis is a critique of the Ada 83 programming language with emphasis on the construction of reusable components and their composition, and more generally on programming "in the large". Ada 83's deficiencies in that area are first described, and then solutions are proposed to most of the problems. The main part of the thesis is a proposal for object-oriented extensions, making classes and objects with inheritance available through package and task types, as a very natural extension of Ada 83's task types. These proposals can be viewed as an alternative to Ada 9X's tagged types, with which a comparison is made

Reports to the President

A compilation of annual reports for the 1982-1983 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

First International Conference on Ada (R) Programming Language Applications for the NASA Space Station, volume 2

Topics discussed include: reusability; mission critical issues; run time; expert systems; language issues; life cycle issues; software tools; and computers for Ada

Programming language abstractions for mobile code

Scala is a general-purpose programming language developed at EPFL. It combines the most important concepts found in object-oriented and functional languages. Scala is a statically typed language; in particular it features an advanced type system and supports local type inference. Furthermore it integrates well with the Java and .net platforms: their libraries are accessible without glue code and the Scala compiler generates code for both execution environments. The Scala programming language has several features that make it desirable as a language for distributed application programming. In particular, it supports first-class functions which are useful in relation with the notions of distributed scope and code mobility. In that context, the missing support for run-time types is one important drawback of the Java run-time environment as a target platform. This thesis focuses on the realisation of a new concept combining essential notions from the functional and distributed programming and implying the extension of the notion of lexical scoping to the distributed context. In short, we claim that the notion of lambda abstraction provides an elegant way for dealing with the dynamic rebinding of local references in a distributed execution environment. The key ideas exposed in this research work have been implemented in our Scala compiler. This helped us to evaluate the used techniques, in particular their impact on the reliability and the performance of distributed programs. So far, most research works related to the present subject have focused on functional programming languages, in particular on the ML language family