An algol-like assembly language for a small computer

In a classic paper¹ Wirth describes a language which combines the readability of ALGOL 60 with the flexibility and degree of control of a conventional assembly language. This paper gives an outline of a similar language for a small 16-bit computer—the Honeywell DDP-516. Implementing the compiler in its own language by recoding an ALGOL version of the compiler has shown that the language is suitable for large systems. With the compiler written in a high-level language, many enhancements have been possible even though these were not envisaged in the original coding This use of the language clearly demonstrated that a high-level assembly language can be a very effective tool for a small machine as well as for computers like the 360 series.     

The design and implementation of a high-level language converter

There is now a good understanding of problems encountered in the design, implementation and use of a high-level language converter. These general issues are illustrated in terms of an account of the design and implementation of one particular converter, which converts programs from Pascal-SC (a Pascal dialect) to Ada. A specific aim of the presentation is to provide guidance for those contemplating future language conversion projects.     

Implementing LISP in a high-level language

The problems of producing an efficient but robust implementation of a high-level language by building on existing compilers are discussed with reference to a LISP system consisting of an interpreter, a compiler and a large collection of support routines. In retrospect it can be seen that almost all of the major difficulties encountered were facets of a general problem concerned with the global control of the use of store. The garbage collector, originally intended solely to manage the LISP heap, extends its scope to simplify the solution of many of these problems.     

Jade: a high-level, machine-independent language for parallelprogramming

Jade, a high-level parallel programming language for managing coarse-grained parallelism, is discussed. Jade simplifies programming by providing sequential-execution and shared-address-space abstractions. It is also platform-independent; the same Jade program runs on uniprocessors, multiprocessors, and heterogeneous networks of machines. An example that illustrates how Jade programmers express irregular, dynamically determined concurrency and how the implementation exploits this source of concurrency is presented. A digital video imaging program that runs on a high-resolution video system and several other examples of Jade applications are described     

A computer simulator for use in an introductory course on computer systems and assembly language programming

This paper describes a simulator for a computer system comprising a simple central processor, memory and a variety of peripheral devices. The simulator is used in the laboratory component of an introductory course on computer systems and assembly language programming. The simulator exploits the limited “cursor graphics” capabilities of commonly available display terminals; the graphics are used to present a view of the internal operations of the simulated computer.     

Adding graphics to a high-level programming language

When graphics input/output capabilities are added to a programming language originally designed with a text stream input/output model, various design decisions affect the ease with which the graphics facilities are learned and used by applications programmers. In adding window system facilities to the Icon programming language, some design decisions were made very differently from the conventional wisdom, resulting in substantial benefits for programmers. In addition, some pre-existing Icon language features have proved to be useful in graphics programming.     

FORK: A high-level language for PRAMs

We present a new programming language designed to allow the convenient expression of algorithms for a parallel random access machine (PRAM). The language attempts to satisfy two potentially conflicting goals: On the one hand, it should be simple and clear enough to serve as a vehicle for human-to-human communication of algorithmic ideas. On the other hand, it should be automatically translatable to efficient machine (i.e. PRAM) code, and it should allow precise statements to be made about the amount of resources (primarily time) consumed by a given program. In the sequential setting, both objectives are reasonably well met by the Algol-like languages, e.g. with the RAM as the underlying machine model, but we are not aware of any language that allows a satisfactory expression of typical PRAM algorithms. Our contribution should be seen as a modest attempt to fill this gap.     

Molecule: a language construct for layered development of parallelprograms

A new language construct, called molecule, is described for the efficient implementation of algorithms on parallel computers. A molecule can be considered a procedure associated with a molecule type. Each molecule type characterizes a particular computation mode (sequential, pipelining, array processing, dataflow, multiprocessing, etc.). Basic concepts of molecule are introduced with a procedural language, called PAL. A concrete example is presented to illustrate layered software development using PAL on a multicomputer (the iPSC). It is concluded that high-level languages, augmented with the molecule construct, offer application flexibility, user friendliness, and efficiency in implementing parallel programs     

The high-level graphics programming language PASCAL/Graph

A high-level programming language like PASCAL offers data types, variables, constants and operators, with which the programmer can represent the actual world as a model inside the computer. The world of numbers and text has been represented in the computer for many years by various kinds of variables. The importance of computer graphics is increasing extremely fast. But the development of high-level programming languages, which include standard constructs for processing graphical informations, is far from where it could be. A good system should be based on understandable concepts, easy to learn and similar to normal programming, so that the programmer can fully concentrate upon the design of his pictures[1–4]. For these purposes PASCAL/Graph³ was designed and implemented[5–8].     

Programming the 68000 in high-level language for VME

Many choices of VME hardware module now exist but software still continues to be the major cost in systems development. As development teams face more complex projects, productivity can be improved by four approaches: the use of standard system architecture, the use of software building blocks, the use of better tools and an increase in the level of software engineering management. Some characteristics of realtime systems programming are presented. Next an overview of the VMEbus is given. Then a target operating environment for 68000-based applications in PASCAL is described. The software components are called pSOS, pHILE and pROP. These provide the realtime executive or kernel, file management system and runtime support for PASCAL respectively. Languages other than PASCAL can be used with pSOS and pHILE, but a preference is expressed for PASCAL over the language C.     

A language for high-level description of adaptive web systems

Adaptive Web systems (AWS) are Web-based systems that can adapt their features such as, presentation, content, and structure, based on users’ behaviour and preferences, device capabilities, and environment attributes. A framework was developed in our research group to provide the necessary components and protocols for the development of adaptive Web systems; however, there were several issues and shortcomings (e.g. low productivity, lack of verification mechanisms, etc.) in using the framework that inspired the development of a domain-specific language for the framework. This paper focuses on the proposal, design, and implementation of AWL, the Adaptive Web Language, which is used to develop adaptive Web systems within our framework. Not only does AWL address the existing issues in the framework, but it also offers mechanisms to increase software quality attributes, especially, reusability. An example application named PENS (a personalized e-News system) is explained and implemented in AWL. AWL has been designed based on the analysis of the adaptive Web domain, having taken into account the principles of reuse-based software engineering (product-lines), domain-specific languages, and aspect-oriented programming. Specially, a novel design decision, inspired by aspect-oriented programming paradigm, allows separate specification of presentation features in an application from its adaptation features. The AWL’s design decisions and their benefits are explained.     

The verification of the protection mechanisms of high-level language machines

A practical methodology for the verification of the protection mechanisms for high-level language machines is presented. It is argued that, although the methodology is informal, it does not lack precision—a feature not found in other informal verification attempts. The methodology has the advantage of ensuring both the correctness and the completeness of the protection mechanisms. The use of the methodology in the verification of systems similar to the Burroughs B6700/6800 is illustrated.     

A program structuring preprocessor for a macro assembly language

This paper deals with design considerations and implementation of a program structuring preprocessor for a macro assembly language. The macro assembly language is used for writing the code generation pass of a compiler. Macro instructions become lengthy, tedious and cumbersome when they incorporate some mild code improvement. This is chiefly because the macro assembly language lacks an adequate program structuring facility. Program structuring is a great help in improving ease of programming and the under-standability of the expansion control statements of a macro instruction in such a kind of programming. Considerations on the design of the source language and the outline of implementation are described. The design objective is ease of implementation and ease of use, and is fairly well satisfied by the language.     

SCOL—A high-level structured language for process control

A high-level process control language, SCOL, was developed to be used in a multi-purpose process control system. Time-dependent process control programming becomes extremely easy using a unique timing attribute mechanism, making the language suitable for real-time applications, where the time factor is a dominant one, while the computation part is of lesser importance. A conventional microcomputer system is used to program the control system for the specific application via an Erasable Programmable Read Only Memory (EPROM). The current release of SCOL is implemented in BASIC, for a control system based on low power 8-bit microprocessor.     

Formula: a programming language for expressive computer music

An overview is given of Formula (an abbreviation for Forth Music Language), a language for controlling synthesizers that can model the expressiveness of a human performance. Formula supports algorithmic composition, interactive performance, and programmed interpretation of traditional scores. It uses concurrent processes that share a single address space and are scheduled by the runtime system. Note-playing processes compute sequences of pitches and play these pitches as notes or chords. Auxiliary processes are attached to note-playing processes or groups to supply note parameters such as volume, duration, and articulation. Input-handling processes execute when input arrives from a particular device. Two representative Formula programs are described