Level Programming Language Research Articles

Supporting software composition at the programming language level

We are in the midst of a paradigm shift toward component-oriented software development, and significant progress has been made in understanding and harnessing this new paradigm. Oddly enough, however, the new paradigm does not currently extend to the level at which components themselves are constructed. While we have composition architectures and languages that describe how systems are put together out of atomic program parts, the parts themselves are still constructed on the basis of a previous paradigm: object-oriented programming. We argue that this mismatch impedes the progress of compositional software design: many of the assumptions that underlie object-oriented languages simply do not apply in the open and dynamic contexts of component software environments. What, then, would a programming language that supported component-oriented programming at the smallest granularity look like? Lag oona, our project to develop such a language, tries to answer this question. This paper motivates the key concepts behind Lag oona and briefly describes their realization (using Lag oona itself as the implementation language) in the context of Microsoft’s .NET environment.

A unifying approach to the security of distributed and multi-threaded programs1

The security of computation at the level of a specific programming language and the security of complex systems at a more abstract level are two major areas of current security research. With the objective to integrate the two, this article proposes an adequate translation of a timing-sensitive security property for simple multi-threaded programs into a more general security framework. Soundness and completeness of the translation guarantee that the trace-based specification of the translation of a multi-threaded program is secure if and only if the original program is secure. Finally, the translation is extended to a distributed setting, and it is demonstrated how to derive global security of the overall system from local security of each thread. The translation is presented as a two-step process where the first step is independent from the concrete programming language.

Making program execution comprehensible one level above the machine language

The aim of courses in computer organization at the introductory level is not to produce qualified assembly language programmers but rather, to make the program's execution and the interaction with the hardware comprehensible at the lower programming language level (above machine code). We briefly describe an environment developed with this aim. Recent findings on the evaluation of visualization environment suggest that the evaluation should focus on the way students actually use these environments to better reveal the expected outcomes. To clarify this issue, we used an evaluation procedure based on this approach that provides far-reaching conclusions on the impact of the use of the environment on students' understanding of program execution.

Negotiable Interfaces for Components.

Component speci cations are vital for communicating a component’s requirements,as components are subject to third-party composition. Most modern programminglanguages lack sucient features to express the full requirements of a component,however, much less enforce them. Pre- and post-conditions can capture functionalaspects of a component’s requirements, but are unable to express many temporalconstraints such as re-entrance restrictions or changing availability of services overthe lifetime of a component instance (object).The approach described within forms a basis for extending the speci cation of compo-nents at the programming language level, thus making such speci cations enforceable.Interfaces are extended with a factorable, abstract state, and methods of interfacesare extended with state transformation behaviours. A new programming languagecommand, the USEstatement, allows clients to negotiate for those services providedby an object. A mixture of static and dynamic checking ensures the consistency ofan object’s state according to the speci cation of the object’s interfaces.The mechanism proposed allows a clearer expression of re-entrance conditions anddynamic service availability, and a greater level of checking that allows erroneouscases to be prevented or detected during development time. The mechanism alsoacts as a self-documenting feature for interfaces.

Complete worst-case execution time analysis of straight-line hard real-time programs

In this article, the problem of finding a tight estimate on the worst-case execution time (WCET) of a hard real-time program is addressed. The analysis is focused on straight-line code (without loops and recursive function calls) which is quite commonly found in synthesised code for embedded systems. A comprehensive timing analysis system covering both low-level (assembler instruction level) as well as high-level aspects (programming language level) is presented. The low-level analysis covers all speed-up mechanisms used for modern superscalar processors: pipelining, instruction-level parallelism and caching. The high-level analysis uses the results from the low-level to compute the final estimate on the WCET. This is done by a heuristic for searching the longest really executable path in the control flow, based on the functional dependencies between various program parts.

A semantics for imprecise exceptions

Some modern superscalar microprocessors provide only imprecise exceptions . That is, they do not guarantee to report the same exception that would be encountered by a straightforward sequential execution of the program. In exchange, they offer increased performance or decreased chip area (which amount to much the same thing).This performance/precision tradeoff has not so far been much explored at the programming language level. In this paper we propose a design for imprecise exceptions in the lazy functional programming language Haskell. We discuss several designs, and conclude that imprecision is essential if the language is still to enjoy its current rich algebra of transformations. We sketch a precise semantics for the language extended with exceptions.The paper shows how to extend Haskell with exceptions without crippling the language or its compilers. We do not yet have enough experience of using the new mechanism to know whether it strikes an appropriate balance between expressiveness and performance.

Sequencing and Preempting Data Flow Tasks

Real-time applications involve the complex sequencing and preemption of different modes of continuous interaction with the environment. This suggests a hybrid language with data flow and sequencing and preemption constructs. To this purpose, we introduce the notion of time interval into the reactive real-time language Signal, which is instant-based, declarative and data-flow oriented. Associating an execution interval with a data flow process specifies a task. Patterns for the sequencing of tasks using time intervals feature parallelism and hierarchical preemption. They are described at the programming language level, as an extension to Signal. They are integrated in the Signal environment by a preprocessor called SignalGTi, and are compatible with its compilation and verification tools.

On the correctness of modular systems

In modular software design it is expected that the correctness of the implementation of a complete system will be a consequence of the correctness of each module. Very often, this property has been associated to the satisfaction of the so-called horizontal and vertical composition properties, both at the specification and at the programming language levels. In this paper we introduce an abstract framework that allows us to represent, as specific instances, most concrete modular fameworks. In particular, the framework presented is “parametrized” by the specification and programming language formalisms, by the semantic constructs associated to modules and by the behavioural equivalence relation used to define module refinement. In addition, the framework is powerful enough to integrate specification and program design by allowing us to deal with incompletely specified systems. In this context, it is shown that, to achieve modular correctness, it is sufficient that the programming language satisfies the property of “stability”, as defined by Schoett, with respect to the given behavioural equivalence relation. In particular, modular correctness is shown to be independent of the satisfaction (or not) of the horizontal and vertical composition properties at the specification level. Finally, it is shown that the property of stability is just a compact formulation of the properties of horizontal and vertical composition at the programming language level.

IPRESPS - a Programming Environment for Partitioning and Scheduling of Time Critical Tasks

Abstract We have developed an integrated programming environment, called IPRESPS, for static partitioning of time critical tasks into concurrent modules and for scheduling those modules for the shortest possible execution time on a model of a macro dataflow computer (MMDFC). IPRESPS consists out of a program graph generation module, a partitioning module, a memory allocation module, a code generation module and a simulation module. The program graph generation module transforms a time critical task (written in DFCL) into a fine grained program graph The partitioning module transforms fine grained program graph into a near optimal grained program graph and schedules it's nodes on the MMDFC. A combination of an algorithm for aggregation of program statements or modules into grains, a DSH algorithm (Kruatrachue and Lewis 1987) and a heuristic algorihm which Increases node size with determination of node's nonstrict inputs (Ojstersek and Žumer 1990) is used for node size determination. A heuristic critical path multi-lists scheduling algorithm is developed for static scheduling of near optimal grained nodes on the MMDFC too. The memory allocation module depending on the static scheduling strategy reserves memory space in units of the MMDFC The code generation module generates sequential code for each node of a near optimal grained program graph. The simulation module (Ojstersek. Žumer, and Veleski 1992) is a loose event-driven block-level simulator that monitors the execution of time critical applications, written in DFCL, which are executed on the MMDFC It enables performance debugging and time critical task debugging at the programming language level, at the abstract machine level, at the model of the computation level and partially at the realization level.

Multitasking: Experience with applications on a CRAY X-MP

On the multiprocessor vector-supercomputer CRAY X-MP, parallelism—beyond vectorization—can be exploited on the programming language level by two multitasking strategies: macrotasking and, more recently, microtasking. In this paper, multitasking results and experiences are presented which have been gained by applying these two implemented modes to linear-algebra and non-numerical algorithms as well as to a large fluid-flow simulation code. While comparing the concepts and realizations of macrotasking and microtasking, the features, tools, and problems of multitasking programming and the potential user benefit of these parallel processing techniques are discussed.

Formal Specification of the Software for a Reactor Safety System

For achievement of highly dependable software the use of formal specification techniques is a must, and an associated tool support is necessary.As an example for a technique and tool environment, the specification system CIP is introduced. CIP (Computer-aided, Intuition-guided Programming) was originally developed at the Technical University of München. It supports the formal specification of software and assists the program development by stepwise transformation. A high level specification is transformed by the application of rules into lower level representation, the lowest level being the programming language level. The transformations preserve the correctness of the specifications.The use of this environment is demonstrated by an example from a safety related reactor control system. Advantages of this approach as well as drawbacks and limitations are explained.

High level programming for distributed computing

Programming for distributed and other loosely coupled systems is a problem of growing interest. This paper describes an approach to distributed computing at the level of general purpose programming languages. Based on primitive notions of module, message, and transaction key, the methodology is shown to be independent of particular languages and machines. It appears to be useful for programming a wide range of tasks. This is part of an ambitious program of development in advanced programming languages, and relations with other aspects of the project are also discussed.

Using a theory of human behavior to analyze the effects of documentation

While this example has mentioned five modeling domains, these same five would not necessarily be present in every task or for all parts of a task. If the task is to implement a particular algorithm for a general purpose algorithm, say, a matrix inversion routine, there will be no domain corresponding to the original domain of cargoes and routes in the example. On the other hand, use of a primitive operation of searching a tree at one level might require use of an intermediate domain, containing methods of tree traversal, before the knowledge could be represented at the programming language level.

Beamline Computer Control by Interpreter

The computer control system for the K9 separated beam is described. This beamline is a multi-energy/ multi-particle beam and the principal aim of the computer system is to reduce the time taken to tune the beam to a new energy. The hardware comprises a 12K PDP-8 with disc and magnetic tape, a Teletype and logging typewriter. Control of the magnet currents and collimators is via a multi-crate CAMAC system, which also serves for data acquisition. The software system is based on a real-time, high level language interpreter. Besides allowing the users to write their programs in a high level language (similar to FORTRAN), the interpreter also provides all the executive functions required with a disc-based, real-time system. Because an interpreter is used, programs can be written or modified on-line and tried out immediately. The relatively slow execution speed of the interpreter is no disadvantage. The system allows high level language and machine code program segments to be combined in any program.