Stress testing of compilers for modula-2

During standardization discussions on Modula-2 the question was raised whether the future standard should need a clause stating a set of minimal requirements for conforming implementations regarding the ‘structuredness’ of lexical, syntactical and run-time constructs in programs written in this language. It was decided to test a number of compilers to find their actual limits on the structuredness of some of these constructs. The test results do not only show these limits, but the inability of some compilers to handle large and complex inputs is shown as well.     

Another approach to the implementation of synchronization primitives

A new method for the implementation of synchronization primitives is described. The method combines the flexibility of user defined primitives with the possibility of compiler checks. The method allows the tailoring of the size and of the performance of the synchronization primitives to the needs of the user.     

A modula-2 kernel for supporting monitors

The concept of the monitor as a device for handling the problems of mutual exclusion and synchronization in a set of concurrent processes is now well understood. In addition to being of considerable theoretical interest, the monitor concept has been found suitable for the design of several practical operating systems. This paper discusses an implementation of monitors using a kernel written in Modula-2.     

Low-level programming in modula-2: An experience with local area network access

Access to a computer network, which is currently a topic of some importance to the high-level language programmer, can be provided in a number of ways. This paper describes one such example, where users of the language Modula-2 were given access to a local area network. The author discusses the type of problem that needs to be overcome, when a language such as Modula-2, which was designed as part of an integrated systems architecture, is used for low-level programming in a different architectural environment.     

One-pass compilation at its limits — A modula-2 compiler for the xerox dragon computer

We present conceptual and implementation aspects of a one-pass Modula-2 compiler that was developed by Xerox PARC's future Dragon workstation. Dragon features several architectural innovations. Among them are a reduced instruction set and a stack of fast registers used to store local data. This paper emphasizes problems and solutions connected with one-pass compilation. Although a little out of fashion at present, this simple method, if appropriately applied, turns out to be surprisingly powerful.     

Language issues in the implementation of a kernel

In this paper we present some issues encountered in the implementation of a kernel for a multiprocessor system using a high level language called CCNPASCAL. We present the nature of the problem concerning each issue, the solutions we adopted and possible better alternatives which we could not adopt for various reasons.     

The programming language standards scene, ten years on Paper 10: Modula-2

This paper, one of a simultaneously published set, describes the establishment in 1984 of the standards project for the programming language Modula-2, and the progress of the project to the end of 1993. This project, including the language itself and an associated library, enters its final phase in 1994. This paper gives a thumbnail sketch of the language, the history of standardization, and the main consequences of changes made during standardization. New work on object-oriented extensions and a Posix binding is also described.     

Ergonomic considerations in the design of interactive languages for process control

The paper introduces the concept of software ergonomics and stresses the importance of respecting the working habits of the user while designing the software aids. Language design criteria are presented under two broad categories: those involving the syntax of the language and those involving its semantics. These criteria are then exemplified using an actual experience of designing an interactive language (TOOL) for a large public utility.     

Automated verification of design patterns: A case study

Representing design decisions for complex software systems, tracing them to code, and enforcing them throughout the lifecycle are pressing concerns for software architects and developers. To be of practical use, specification and modeling languages for software design need to combine rigor with abstraction and simplicity, and be supported by automated design verification tools that require minimal human intervention. This paper examines closely the use of the visual language of Codecharts for representing design decisions and demonstrate the process of verifying the conformance of a program to the chart. We explicate the abstract semantics of segments of the Java package java.awt as a finite structures, specify the Composite design pattern as a Codechart and unpack it as a set of formulas, and prove that the structure representing the program satisfies the formulas. We also describe a set of tools for modeling design patterns with Codecharts and for verifying the conformance of native (plain) Java programs to the charts.     

ARTK-M2: A kernel for Ada tasking requirements: An implementation and an automatic generator

A run-time kernel, ARTK-M2, supporting Ada tasking semantics is discussed; full support for task creation, synchronization, communication, scheduling, and termination is provided, together with all options of the Ada rendezvous. An implementation in Modula-2 is presented and a method for automatically translating Ada programs into semantically equivalent Modula-2 programs with corresponding kernel calls is introduced. A parser generator and an attribute grammar were used for the automatic translation. A subset of the Ada Compiler Validation Capability was processed to test the implementation and to illustrate the translation mechanism. The kernel is applicable to the study of real-time control systems; it can also serve as a baseline for studying implementation alternatives of Ada concepts, such as new scheduling algorithms, and for analysing new language constructs. Work is under way to implement some of the changes to the Ada tasking model being proposed as a result of the language revision (Ada9X). Finally, through proper extensions, ARTK-M2 can form an integral part of programming tools such as an Ada compilation system and a distributed kernel for multi-processing environments.     

Implementation of a computer job scheduling algorithm: A case history

Multiprogramming systems require that a fair, equitable algorithm be used for the scheduling of jobs. This paper discusses some of the problems associated with this and proposes an automatic job scheduling algorithm. The major parts of the algorithm have been implemented and have been in use for over one year. The user interface is simplified and the operational complexities are minimized. The parameters used for the algorithm are the estimates of the central processor time and the memory required by the job. All types of jobs including those requiring operator attention during execution are covered under the scheme. Operational data and the reactions from the users indicate that the results have been as expected.     

Building a real-time kernel: First steps in validating a pure process/ADT model

A model based on simple, unadorned processes and abstract data types has been proposed for the design and implementation of real-time systems. We describe our generally successful experiences in using this model for the construction of a real-time operating system kernel containing services for process control, synchronization, time and input-output. Our work and results focus on the usefulness of the scheme for designing modules at hardware/software interfaces, for predicting deterministic timing behaviour, and for software development.     

Building an interaction design pattern language: A case study

Interaction design patterns are a proven way to communicate good design. However, current pattern collections are not sufficiently powerful and generative to be used as a guide for designing an entire application such as those used in complex business environments. This study shows how we built and validated interaction design patterns that serve as the specification for the redesign of an application. Additionally, they were integrated into a pattern language, as a ruleset for human–computer interaction (HCI) non-professionals to continue development of the application. We demonstrate how individual phases in the redesign of an application can be matched with the process of creating an interaction design pattern language. To facilitate the writing of individual interaction design patterns as well as the development of the pattern language as a whole, a combination of user interviews, controlled experiments and analytical methods has been applied successfully.     

Software concurrency in real time control systems: A software nucleus

This paper gives the rationale for the design of a nucleus to support real time control applications. In particular, mechanisms for communication between concurrent tasks are reviewed and analysed in the context of this application area. Finally, although no implementation is discussed in detail, techniques which have proved useful in implementing this nucleus on three different machines are described.     

CBack: A simple tool for backtrack programming in C

Backtrack programming is such a powerful technique for problem solving that a number of languages, especially in the area of artificial intelligence, have built-in facilities for backtrack programming. This paper describes CBack, a simple, but general tool for backtrack programming in the programming language C. The use of the tool is illustrated through examples of a tutorial nature. In addition to the usual depth-first search strategy, CBack provides for the more general heuristic best-first search strategy. The implementation of CBack is described in detail. The source code, shown in its full length, is entirely written in ANSI C and highly portable across diverse computer architectures and C compilers.     

Requirements for a COTS software component: A case study

The goal of the GUARDS project is to design and develop a generic fault-tolerant computer architecture that can be built from predefined standardised components. The architecture favours the use of commercial off-the-shelf (COTS) hardware and software components. However, the assessment and selection of COTS components is a non-trivial task as it requires balancing a myriad of requirements from end-users and the preliminary architecture design. In this paper, we present the requirements and assessment criteria for a specific COTS software component, the operating system kernel. As an interface specification constitutes a major compatibility criterion for the selection of COTS components in GUARDS, a particular emphasis is placed on operating system conformance to the POSIX 1003.1 standard. We discuss the general lessons learned from the assessment process and raise a number of questions relevant to the assessment of any COTS software component.     

ADA: A language for robot programming?

Robot programming languages are emerging from their experimental stage and entering an assessment phase. Their main features are illustrated and a parallel with ADA is proposed. The comparison is positive for ADA, in the sense that ADA provides most of the required capabilities. The ability of reasoning on object models and taking decisions will play an increasing role in the future. In this case the role of ADA would possibly change and its interest as robot programming language decrease.     

Automatically wrapping legacy software into services: A grid case study

The computational grid is rapidly evolving into a service-oriented computing infrastructure that facilitates resource sharing for solving large-scale data and computationally intensive problems. Peer-to-peer (P2P) systems have emerged as an infrastructure enabling technologies for enhanced scalability and reliability in file sharing and content distribution. It is envisioned that P2P enabled service-oriented grid systems would virtualize various resources as services with high scalability and reliability. Many legacy software resources exist nowadays, but making them grid aware services for effective resource sharing has become an issue of vital importance. This paper presents GSLab, a toolkit for automatically wrapping legacy software into services that can be published, discovered and reused in grid environments. GSLab employs Sun Grid Engine (SGE) to enhance its performance in execution of wrapped services. Using GSLab, we have automatically wrapped a legacy computer animation rendering code written in C as a service that can be discovered and accessed in a SGE environment. The evaluation results show that the performance of GSLab improves with an increase in the number of computing nodes involved.

Monitoring student progress using virtual appliances: A case study

The interactions that students have with each other, with the instructors, and with educational resources are valuable indicators of the effectiveness of a learning experience. The increasing use of information and communication technology allows these interactions to be recorded so that analytic or mining techniques are used to gain a deeper understanding of the learning process and propose improvements. But with the increasing variety of tools being used, monitoring student progress is becoming a challenge. The paper answers two questions. The first one is how feasible is to monitor the learning activities occurring in a student personal workspace. The second is how to use the recorded data for the prediction of student achievement in a course. To address these research questions, the paper presents the use of virtual appliances, a fully functional computer simulated over a regular one and configured with all the required tools needed in a learning experience. Students carry out activities in this environment in which a monitoring scheme has been previously configured. A case study is presented in which a comprehensive set of observations were collected. The data is shown to have significant correlation with student academic achievement thus validating the approach to be used as a prediction mechanism. Finally a prediction model is presented based on those observations with the highest correlation.