Pascal-like Language Research Articles

Students’ perspective on the first programming language: C-like or Pascal-like languages?

The choice of the first programming language (FPL) has been a controversial issue for several decades. Nearly everyone agrees that the FPL is important and affects students’ subsequent education on programming. The study presented in this article investigates the suitability of various C-like and Pascal-like programming languages as a FPL. Students from three Universities express their perceptions on the FPL through a specially designed questionnaire. The students had been introduced to programming using different FPLs and having experience on more than one language and formulated two distinct groups: a group introduced to programming with a C-like and another with a Pascal-like language. The statistical analysis of the data collected showed that the choice of the FPL does not have a deep impact on difficulties that novices may experience when learning the basics of programming. However, this result was recorded in the context of three distinct programming courses that were positively evaluated by students in relation to their content, organization and quality. Consequently, this study indicates that the overall quality of the course and the instructors have a great impact on a smooth introduction to programming no matter what the FPL is.

A Task-driven Grammar Refactoring Algorithm

This paper presents our proposal and the implementation of an algorithm for automated refactoring of context-free grammars. Rather than operating under some domain-specific task, in our approach refactoring is perfomed on the basis of a refactoring task defined by its user. The algorithm and the corresponding refactoring system are called mARTINICA. mARTINICA is able to refactor grammars of arbitrary size and structural complexity. However, the computation time needed to perform a refactoring task with the desired outcome is highly dependent on the size of the grammar. Until now, we have successfully performed refactoring tasks on small and medium-size grammars of Pascal-like languages and parts of the Algol-60 programming language grammar. This paper also briefly introduces the reader to processes occurring in grammar refactoring, a method for describing desired properties that a refactored grammar should fulfill, and there is a discussion of the overall significance of grammar refactoring.

Learning compiler construction by examples

In traditional compiler construction courses, each compiler phase is studied in detail before moving on to the next one. This not only places a great distance between theory and practice but also makes the students lose the big picture of the subject. We have been employing a different course format in which the subject is incrementally introduced through ten compilers of increasingly complexity. The first compiler is in fact just a syntax analyzer of a very simple language. The last one is a complete compiler of a Pascal-like language. Students of this course learn how to build compilers faster than the usual.

Towards a demonstrably-correct ada compiler

We report on a significant new compiler technology for applications requiring the highest level of reliability. This work is partly funded by AWE plc and takes into account previous AWE work on a demonstrably correct compiler for a Pascal-like language. This work will be of interest to anyone developing safety-critical software. Today's Ada compilers are based on 1980s' technology, when 4M Bytes of memory was considered sufficient for a project of 10 users. Using today's computers, when even a laptop computer has 512 M Bytes of memory; we can offer a much better compiler for a fraction of the cost. Initial estimates suggest a new technology compiler will be 1/50th the number of source lines, yet meet all our requirements for features and run-time performance. We have already confirmed the feasibility of our approach in a prototype compiler. This handles a well-defined subset of Ada95 and employs algebraic simplifications in place of optimizations. By prohibiting recursion, we avoid costly run-time organization. Our prototype run-time system is just three instructions. Our compiler is written in a notation much like ordinary mathematics, and is therefore amenable to mathematical techniques such as theorem proving. Later we intend to offer a proof of correctness. In the meantime, we will demonstrate correctness, both in the sense that a given program has been correctly compiled, and that all programs will be correctly compiled. The prototype compiler performs well. It compiles at several thousand lines per second and generates code that compares well with that from our optimizing compiler.

Correctness of data representations involving heap data structures

While the semantics of local variables in programming languages is by now well-understood, the semantics of pointer-addressed heap variables is still an outstanding issue. In particular, the commonly assumed relational reasoning principles for data representations have not been validated in a semantic model of heap variables. In this paper, we define a parametricity semantics for a Pascal-like language with pointers and heap variables which gives such reasoning principles. It turns out that the correspondences between data representations cannot simply be relations between states, but more intricate correspondences that also need to keep track of visible locations whose pointers can be stored and leaked.

Bridging the algorithm gap: A linear-time functional program for paragraph formatting

In the constructive programming community it is commonplace to see formal developments of textbook algorithms. In the algorithm design community, on the other hand, it may be well known that the textbook solution to a problem is not the most efficient possible. However, in presenting the more efficient solution, the algorithm designer will usually omit some of the implementation details, thus creating an algorithm gap between the abstract algorithm and its concrete implementation. This is in contrast to the formal development, which usually proceeds all the way to the complete concrete implementation of the less efficient solution. We claim that the algorithm designer is forced to omit some of the details by the relative expressive poverty of the Pascal-like languages typically used to present the solution. The greater expressiveness provided by a functional language would allow the whole story to be told in a reasonable amount of space. In this paper we use a functional language to present the development of a sophisticated algorithm all the way to the final code. We hope to bridge the algorithm gap between abstract and concrete implementations, and thereby facilitate communication between the constructive programming and algorithm design communities.

Correctness of on-line partial evaluation for a Pascal-like language

An on-line partial evaluator for an imperative language is formally defined and proven to be correct. As far as we know, this is the first correctness proof of an on-line partial evaluator. The proof consists of several lemmata showing the correctness of partial evaluation of expression and the invariance of certain properties of the environments under partial/residual and total evaluation. The language the partial evaluator is based on contains functions as well as procedures with value, result, and reference parameters and side-effects.

Duality for semilattice representations

The paper presents general machinery for extending a duality between complete, cocomplete categories to a duality between corresponding categories of semilattice representations (i.e. sheaves over Alexandrov spaces). This enables known dualities to be regularized. Among the applications, regularized Lindenbaum-Tarski duality shows that the weak extension of Boolean logic (i.e. the semantics of PASCAL-like programming languages) is the logic for semilattice-indexed systems of sets. Another application enlarges Pontryagin duality by regularizing it to obtain duality for commutative inverse Clifford monoids.

The II parallel programming system

A parallel random access machine (PRAM)-oriented programming language called II and its implementation on transputer networks are presented. The approach taken is a compromise between efficiency and simplicity. The II language has been conceived as a tool for the study, design, analysis, verification, and teaching of parallel algorithms. One of the main features of this Pascal-like language is the ability to mix parallelism and recursion allowing a simple and elegant formulation of a large number of parallel algorithms. A method for the complexity analysis of II programs, called PRSW, is introduced. The current version of the II compiler guarantees the conservation of the PRSW complexity of the algorithms translated. Furthermore, the computational results show a good behavior of the system for PRAM efficient algorithms.

BEE: a special-purpose machine for hardware description languages

The goal of designing a special-purpose computer is to offer a highly efficient computer-aided environment for circuit simulation using hardware description languages. The suggestion is to have a machine that supports bitstring operations. A bitstring comprises a sequence of bits and must have at least one bit, and is found to be the predominant operation in hardware description languages, yet not a common operation in Pascal-like languages. A special-purpose machine is proposed and its hardware architecture reflects the characteristics of a hardware description language. The main part of this paper deals with the design concepts of the hardware machine, which is derived directly from the run-time requirements of hardware description programs. We start by examining examples of these programs and their operators, then identifying areas which can be improved through the use of hardware. Next, we present the architecture of the machine and bitstring operators that are supported. The instruction format is also presented and some comparisons are made to the reduced instruction set computers. Finally, we study the related works that have been conducted elsewhere.

A process oriented semantics of the PRAM-language FORK

The parallel language FORK [1], based on a scalable shared memory model, is a PASCAL-like language with some additional parallel constructs. A PRAM (Parallel Random Access Machine) algorithm can be expressed on a high level of abstraction as a FORK program which is translated into efficient PRAM code guaranteeing theoretically predicted runtimes. In this paper, we concentrate on those features of the language FORK related to parallelism, such as the group concept, a shared memory access and synchronous or asynchronous execution. We present a trace-based denotational interleaving semantics where processes describe synchronous computations. Processes are created or deleted dynamically and run asynchronously. Interleaving rules reflect the underlying CRCW (concurrent-read-concurrent-write) PRAM model.

Proving properties of real-time systems through logical specifications and Petri net models

Addresses the problem of formally analyzing the properties of real-time systems. We propose a method based on modeling the system as a timed Petri net and on specifying its properties in TRIO, an extension of temporal logic suitable for dealing explicitly with time and for measuring it. Timed Petri nets are axiomatized in terms of TRIO, so that their properties can be derived as theorems in the same spirit as the classical Hoare method allows one to prove properties of programs coded in a Pascal-like language. The method is also illustrated through an example. >

Proof rules for recursive procedures

Abstract Four proof rules for recursive procedures in a Pascal-like language are presented. The main rule deals with total correctness and is based on results of Gries and Martin. The rule is easier to apply than Martin's. It is introduced as an extension of a specification format for Pascal-procedures, with its associated correctness and invocation rules. It uses well-founded recursion and is proved under the postulate that a procedure is semantically equal to its body. This rule for total correctness is compared with Hoare's rule for partial correctness of recursive procedures, in which no well-founded relation is needed. Both rules serve to prove correctness, i.e. sufficiency of certain preconditions. There are also two rules for proving necessity of preconditions. These rules can be used to give formal proofs of nontermination and refinement. They seem to be completely new.

ESP, a structure synthesis program

In this paper we present the implementation of a silicon compiler which generates the layout of digital systems from their description at register transfer level. The system presented, called ESP, takes the RT level description, write in a Pascal-like language, and converts it into a circuit description in EDIF.

Rapid prototyping of ASICs with OASIS

OASIS is a cell-based design system with four major components: the compiler and logic synthesizer, the simulator and verifier, the automatic test pattern generator, and the automatic layout generator. The design flow is top-down as illustrated in the chart below. Currently, the design is captured in LOGIC-III, a PASCAL-like programming language that combines both the functional and structural descriptions. The functional description specifies finite state machines and decoding logic that can be readily synthesized into circuit structures by way of logic synthesis. A scan-path can be inserted automatically in every synthesized component. Data-path circuits are synthesized hierarchically from parameterized structural/functional descriptions of subcomponents. Tools for redundancy identification can be used to detect and to remove any untestable logic.

A syntax-directed integrated programming environment for developing simd supercomputer software

The increasing availability and use of supercomputers has highlighted the need for better software development techniques and tools. Supercomputers have traditionally been extensively used by engineers and scientists whose preference for Fortran is well established and recognized. However, in the parallel environment offered by the latest configurations of supercomputers, more sophisticated languages and tools are required. The present experiment is concerned with devising a syntax-directed integrated programming environment based on the language Actus, which enables a user to develop and debug programs before submitting them to an actual supercomputer. Actus is a high-level, Pascal-like language, with SIMD parallel processing features. It enables the user to ignore the idiosyncrasies of the chosen supercomputer by abstracting the parallel processing detail to a higher level. The editing, compilation and testing phases of program development are all integrated, providing a single consistent interface for all activities relating to program development.

Signal-to-string conversion based on high likelihood regions using embedded dynamic programming

A method of signal-to-string conversion based on embedded dynamic programming (DP) which can adapt its search to the variation of the input signal is proposed. The optimizing process is guided by high-valued portions of the likelihood function of symbols composing the string and is solved by two embedded dynamic programming processes. Algorithms in a Pascal-like language relating to the solution are given. When applied to continuous speech recognition on a 100-word vocabulary using the phoneme as the basic recognition unit, the method is shown to achieve a 4% improvement in the recognition rate compared to a classical DP-based method.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Programming with streams in a Pascal-like language

A description is given of features which were added to a conventional programming language that will manipulate streams of values. A stream is a sequence of values of a certain fixed type. The number of elements of a stream may be determined at execution time, and evaluation of each element can be postponed until its value is actually needed. Many programs can be expressed naturally and clearly as networks of processes communicating by means of streams. The network is called a composite function and consists of several component functions. Since component functions are connected solely by streams, they greatly increase the flexibility of combinations and the reusability of programs. Loop statements can be considered as iterative statements over streams. One general problem in these networks is the mechanism of terminating each process of the network. A practical solution for this problem is presented. Comparisons to other programming styles, such as coroutines, Lisp, functional programming, and dataflow languages, are described. Three modes of execution are considered for the implementation of composite functions: parallel mode, coroutine mode, and inline mode. In the inline mode, a composite function is expanded and transformed into a single function, realizing maximum run-time efficiency. Algorithms for this expansion are given. >

Transformations of sequential specifications into concurrent specifications by synchronization guards

A transformation C of sequential specifications into concurrent specifications is defined. The sequential specification is in the form of a regular expression extended with a declaration of the actions that are independent and have the potential for concurrent execution. The concurrent specification is in the form of a product of regular expressions. It is proved that a concurrent specification resulting from the application of the transformation C to a sequential specification modified by inserting special actions, called synchronization guards, is behaviorally equivalent to the original specification. The programming language representation of a sequential specification is exemplified in a Pascal-like language, Banach.

Pyramidal algorithms for iconic indexing

We introduce algorithms for symbolic picture matching on a pyramidal architecture. The algorithms are written in a Pascal-like language extended with high level pyramidal control structures. The time complexicty has been calculated by considering no overlapping among the execution phase of the host computer and those of the single layers of the pyramid. We can also use the pyramidal architecture to generate the iconic index of a symbolic picture