Modules program structures and the structuring of operating systems

In this paper some views are presented on the way in which complex systems, such as Operating Systems and the programs to be interfaced with them can be constructed, and how such systems may become heavily library oriented. Although such systems have a dynamic nature, all interfacing within and among modules can be checked statically. It will be shown that the concepts presented are equally valid for single user systems, multi-programming systems and even distributed systems. The ideas have been spurred by the implementation of a modular version of Pascal and a supporting Operating System, currently nearing completion at Twente University of Technology, The Netherlands

A study of systems implementation languages for the POCCNET system

The results are presented of a study of systems implementation languages for the Payload Operations Control Center Network (POCCNET). Criteria are developed for evaluating the languages, and fifteen existing languages are evaluated on the basis of these criteria

Extending Attribute Grammars to Support Programming-in-the-Large

Attribute grammars add specification of static semantic properties to context-free grammars, which in turn describe the syntactic structure of program units. However, context-free grammars cannot express programming-in-the-large features common in modern programming languages, including unordered collections of units, included units and sharing of included units. We present extensions to context-free grammars, and corresponding extensions to attribute grammars, suitable for defining such features. We explain how batch and incremental attribute evaluation algorithms can be adapted to support these extensions, resulting in a uniform approach to intra-unit and inter-unit static semantic analysis and translation of multi-unit programs

An operating system for future aerospace vehicle computer systems

The requirements for future aerospace vehicle computer operating systems are examined in this paper. The computer architecture is assumed to be distributed with a local area network connecting the nodes. Each node is assumed to provide a specific functionality. The network provides for communication so that the overall tasks of the vehicle are accomplished. The O/S structure is based upon the concept of objects. The mechanisms for integrating node unique objects with node common objects in order to implement both the autonomy and the cooperation between nodes is developed. The requirements for time critical performance and reliability and recovery are discussed. Time critical performance impacts all parts of the distributed operating system; e.g., its structure, the functional design of its objects, the language structure, etc. Throughout the paper the tradeoffs - concurrency, language structure, object recovery, binding, file structure, communication protocol, programmer freedom, etc. - are considered to arrive at a feasible, maximum performance design. Reliability of the network system is considered. A parallel multipath bus structure is proposed for the control of delivery time for time critical messages. The architecture also supports immediate recovery for the time critical message system after a communication failure

Compiling knowledge-based systems from KEE to Ada

The dominant technology for developing AI applications is to work in a multi-mechanism, integrated, knowledge-based system (KBS) development environment. Unfortunately, systems developed in such environments are inappropriate for delivering many applications - most importantly, they carry the baggage of the entire Lisp environment and are not written in conventional languages. One resolution of this problem would be to compile applications from complex environments to conventional languages. Here the first efforts to develop a system for compiling KBS developed in KEE to Ada (trademark). This system is called KATYDID, for KEE/Ada Translation Yields Development Into Delivery. KATYDID includes early prototypes of a run-time KEE core (object-structure) library module for Ada, and translation mechanisms for knowledge structures, rules, and Lisp code to Ada. Using these tools, part of a simple expert system was compiled (not quite automatically) to run in a purely Ada environment. This experience has given us various insights on Ada as an artificial intelligence programming language, potential solutions of some of the engineering difficulties encountered in early work, and inspiration on future system development

Pascal-orientated computer design

Imperial Users onl

Linkage kinematics sketchpad

During the design and creation of linkage-type mechanisms, visualization of linkage motion is extremely important. However, there does not appear to be a commercially available computer package for accomplishing visualization interactively. Most linkage design packages allow animation of linkage motion only after tedious part description (and debug) using cryptic input codes. The main thrust of this work has been the development of a prototype interactive graphics (CAD) system aimed at visualizing the motion and mobility of linkage-type mechanisms. The program is called the Linkage Kinematics Sketchpad (LKSP). It is a 2-D color graphics program which allows the user to describe a limited set of linkages (limited by a simplified kinematics analysis procedure) and interactively drive the linkage through its inherent motion cycle (or parts thereof) to visualize mobility . First, a theoretical investigation of previous work in motion analysis and display of animation is presented. This is followed by a description of the LKSP program and an evaluation of the software by this author and others more familiar with linkage design. The system design appears to be adequate, and the software is correct with linkage motions as required. As a result of this work the usefulness of this approach has been determined, and a reasonable methodology has been established. Also, problem areas have been defined, and potentially fruitful areas for future work have been identified. LKSP offers a unique approach to planar linkage design with the most desirable features being the interactive user-computer interface, the ability to create linkages with ease, and the ability to observe linkage motion and potential interference. The most commonly cited shortcoming was the limited set of linkage components which LKSP can handle. Also, there were some aspects of the motion animation which were improved as a result of the user evaluations. Suggestions for future extensions include more user control over the motion animation and more precise input of linkage dimensions

Type-safe composition of object modules

Journal ArticleWe describe a facility that enables routine type-checking during the linkage of external declarations and definitions of separately compiled programs in ANSI C. The primary advantage of our server-style type-checked linkage facility is the ability to program the combination of object modules via a suite of strongly typed module operators. Such programmability enables one to easily incorporate programmer-defined data format conversion stubs at link-time. In addition, our linkage facility is able to automatically generate safe coercion stubs for compatible encapsulated data.