Block-structured Language Research Articles

Revised6 Report on the Algorithmic Language Scheme

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language. Scheme was the first major dialect of Lisp to distinguish procedures from lambda expressions and symbols, to use a single lexical environment for all variables, and to evaluate the operator position of a procedure call in the same way as an operand position. By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially gotos that pass arguments. Scheme was the first widely used programming language to embrace first-class escape procedures, from which all previously known sequential control structures can be synthesized. A subsequent version of Scheme introduced the concept of exact and inexact number objects, an extension of Common Lisp's generic arithmetic. More recently, Scheme became the first programming language to support hygienic macros, which permit the syntax of a block-structured language to be extended in a consistent and reliable manner.

Adjustment of Performance for the Application of PL/SQL

The oracle database system is the large relation database management system which is applied most broadly at present. The PL/SQL language is a sort of block structured language, and it is the procedural language that the Oracle extends SQL, and it allows encapsulating operation logics, and its advantage is to use inscribed SQL sentence to define and realize 3GL language structure and describe more complex query, trigger, memory process and other objectives. Therefore, to more reasonably use PL/SQL program can exert important function to implement the Oracle database performances. Through the adjustment of database shared pool and the introduction of different technologies of data access, we discussed some technologies to enhance the implementation performance of PL/SQL and optimize the performance of the database system by means of PL/SQL language.

Pattern-Based Translation of BPMN Process Models to BPEL Web Services

The business process modeling notation (BPMN) is a graph-oriented language primarily targeted at domain analysts and supported by many modeling tools. The business process execution language for Web services (BPEL) on the other hand is a mainly block-structured language targeted at software developers and supported by several execution platforms. Translating BPMN models into BPEL code is a necessary step towards standards-based business process development environments. This translation is challenging since BPMN and BPEL represent two fundamentally different classes of languages. Existing BPMN-to-BPEL translations rely on the identification of block-structured patterns in BPMN models that are mapped onto structured BPEL constructs. This article advances the state of the art in BPMN-to-BPEL translation by defining methods for identifying not only perfectly block-structured fragments in BPMN models, but quasi-structured fragments that can be turned into perfectly structured ones and flow-based acyclic fragments that can be mapped onto a combination of structured constructs and control links. Beyond its direct relevance in the context of BPMN and BPEL, this article addresses issues that arise generally when translating between graph-oriented and block-structured flow definition languages.

Optimizing Procedure Calls in Block-structured Languages

Static chains and displays are two techniques used by compilers to implement variable references for block-structuredprogramming languages. Both methods impose significant run-time overhead during procedure calls and variable references. This paper investigates several optimizations to improve upon common practice. The effectiveness of the various schemes is measured by collecting dynamic reference traces from executing Ada programs and assigning costs for procedure calls and variable references using two cost models. One model assumes a complex instruction-set architecture and the other assumes a reduced instruction-set architecture. Optimizations to the static chain scheme are found to significantly reduce its overall cost and approach the cost of the display scheme while using fewer registers than a display.

Full abstraction for the second order subset of an Algol-like language

We present a denotational semantics for an Algol-like language Alg, which is fully abstract for the second order subset of Alg. This constitutes the first significant full abstraction result for a block structured language with local variables. As all the published ‘test equivalences’ [8, 13,22] for Algol-like languages are contained in the second order subset, they can all be validated (easily) in our denotational model. The general technique for our model construction — namely ‘relationally structured locally complete partial orders’ with ‘relation preserving locally continuous functions’ — has already been developed in [13], but our particular model differs from the one in [13] in that we now use a larger set of relations. In a certain sense it is the ‘largest possible’ set of relations, an idea which we have successfully used in [32] to obtain a fully abstract model for the second order subset of the functional language PCF [26]. The overall structure of our full abstraction proof is also taken from [32], but for the single parts of the proof we had to solve considerable new problems which are specific to the imperative ( Algol-like) setting.

Audio formatting — presenting structured information aurally

We have developed a computing system that takes a LATEX source as input and speaks it. The system is interactive in that the user can browse the document to listen to the parts that most interest him. Special attention has been given to the speaking of mathematical formulas; in this realm, the system outperforms humans. The system is designed primarily for the sight-impaired, but it has a much broader potential. AFL, the audio analogue of PostScript (Adobe Systems), for paper output is smaller than PostScript and consists of a simple block-structured language in which one writes commands that cause words to be spoken and sounds to be played. AFL is used to vary output parameters such as the speed of the spoken word, the pitch of the voice, and the length of pauses. AFL also synchronizes various sound components. The presence of AFL has allowed us to experiment extensively with various ways of speaking mathematics to arrive at effective audio renderings. The design of AFL is the focus of this paper.

Dynamic semantic specification by two-level grammars for a block structured language with subroutine parameters

This paper presents the application of a formal description language -- Van Wijngaarden Two-Level grammar -- to define the dynamic semantics of a block structured language consisting of several types of parameter passing mechanisms. We will show, in a fairly understandable, concise and clear fashion, that the metalinguistic formalism of Two-Level grammar is a fine descriptive device for this purpose.

Representation of Process Planning Knowledge for Part Families

The paper describes the representation of process planning knowledge utilized in a process planner under development at the Helsinki University of Technology. The planner puts special emphasis on the representation and processing of group technological part families. Part families are represented on the basis of a feature model which is associated with a family-specific plan specification encoded in a block structured definition language. The plan specification can be evaluated at planning time to yield a process plan. The evaluation process encapsulates the search amongst predefined alternatives and the required consideration of part instance-specific knowledge. The work is considered a contribution to computer-aided process planning methodology.

An empirical investigation of menu design in language-based editors

In program visualization some form of graphics is used to represent some aspect of a program. However, graphics are necessarily expensive with respect to “screen real estate”. Alternatives, therefore, may be required for presentation of certain concepts fundamental to the programmer's model of a program. For example, one graphical representation of a program, written in a block-structured language like Pascal or Modula-2, is the structure chart model of the hierarchical structure of the blocks or modules making up the program. This graphic may be the most appropriate but it may not be conveniently implemented as a menu and a means of “directly” selecting blocks of program code to view or edit. Such graphics are used extensively, for example, in the Garden environment developed at Brown University. An alternative is a text-based list of block names indented to summarize the program's structure. UQ1, a language-based editor developed at the University of Queensland, implements the concept in this manner. Both types of menu structure were examined and compared for efficiency in a direct manipulation style of interaction. In general, there was no significant difference ( P > 0.05) in time taken by subjects to select items from either style of menu.

Extending Horn clause logic with implication goals

The paper deals with the problem of extending positive Horn clause logic by introducing implication in goals as a tool for programs structuring. We allow a goal G i in a clause G 1 ∧⋯∧ G n → A to be not only an atom but also an implication D ⊃ G (we shall it an implication goal), where D is a set of clauses and G a goal. This extension of the language allows local definitions of clauses in logic programs. In fact, an implication goal D ⊃ G can be thought of as a block ( D, G), where D is the set of local clause declarations. In this paper we define a language with blocks in which, as in conventional block structured programming languages, static scope rules have been chosen for locally defined clauses. We analyse static scope rules, where a goal can refer only to clauses defined in statically surrounding blocks, and we compare this extension with other proposals in the literature. We argue, on account of both implementative and semantic considerations, that this kind of block structured language is a very natural extension of Horn clauses when used as a programming language. We show it by defining an operational, fixpoint and model–theoretic semantics which are extensions of the standard ones, and by proving their equivalence. We show that static scope rules can be obtained by interpreting → as classical and ⇒ as intuitionistic implication with respect to Herbrand interpretations.

An investigation into concurrent semantic analysis

Concurrency is an attractive method for reducing the execution time of compilers. By dividing source programs into segments which can be compiled concurrently, the task of compiling programs can be accelerated. Many of the difficult problems which arise when constructing a concurrent compiler occur in the implementation of the semantic analyser. This paper investigates the problems involved in designing the semantic analyser for a concurrent compiler for a modern, block-structured language. Several approaches to solving the problems which arise are presented. These solutions are then implemented as part of a concurrent Modula-2 + compiler, running on a shared memory multiprocessor. A performance evaluation of these semantic analysers is presented.

NEST: a network simulation and prototyping testbed

NEST: a network simulation and prototyping testbed

Synchronised execution on shared memory multiprocessors

Threads provides a mechanism for simulating the execution of parallel algorithms on a simplified model of a shared-memory multiprocessor. The algorithms can be expressed in a high-level block-structured language, which supports multiple threads of execution within a common body of program code. Results show an ability to achieve good speedup for small problems using algorithms derived by simple modifications of sequential algorithms. As well, a sibling thread synchronisation feature provides the basis for the synchronous execution of threads. k-parallel algorithms tailored to the machine size and implemented as synchronously executing iterations, can provide near linear speedup as the problem size is increased. The techniques described in this paper seem to promise an effective synchronous execution mode for shared-memory MIMD architectures.

Combining language and database advances in an object-oriented development environment

Object-oriented languages generally lack support for persistent objects—that is objects that survive the process or programming session. On the other hand, database systems lack the expressibility of object-oriented languages. Both persistence and expressibility are necessary for production application development. This paper presents a brief overview of VBASE, an object-oriented development environment that combines a procedural object language and persistent objects into one integrated system. Language aspects of VBASE include strong datatyping, a block structured schema definition language, and parameterization, or the ability to type members of aggregate objects. Database aspects include system support for one-to-one, one-to-many, and many-to-many relationships between objects, an inverse mechanism, user control of object clustering in storage for space and retrieval efficiency, and support for trigger methods. Unique aspects of the system are its mechanisms for custom implementations of storage allocation and access methods of properties and types, and free operations, that is operations that are not dispatched according to any defined type. During the last several years, both languages and database systems have begun to incorporate object features. There are now many object-oriented programming languages. [Gol1983, Tes1985, Mey 1987, Cox 1986, Str 1986]. Object-oriented database management systems are not as prevalent yet, and sometimes tend to use different terms (Entity-Relationship, Semantic Data Model), but they are beginning to appear on the horizon [Cat1983, Cop1984, Ston1986, Mylo1980]. However, we are not aware of any system which combines both language and database features in a single object-oriented development platform. This is essential since a system must provide both complex data management and advanced programming language features if it is to be used to develop significant production software systems. Providing only one or the other is somewhat akin to providing half a bridge: it might be made structurally sound, perhaps, but it is not particularly useful to one interested in getting across the river safely. Object-oriented languages have been available for many years. The productivity increases achievable through the use of such languages are well recognized. However, few serious applications have been developed using them. One reason has been performance, though this drawback is being eliminated through the development of compiled object languages. The remaining major negative factor, in our view, is the lack of support for persistence; the lack of objects that survive the processing session and provide object sharing among multiple users of an application. Database management systems, in contrast, suffer from precisely the opposite problem. While having excellent facilities for managing large amounts of data stored on mass media, they generally support only limited expression capabilities, and no structuring facilities. Both language and database systems usually solve this problem by providing bridges between the systems. Thus the proliferation of 'embedded languages', allowing language systems to access database managers. These bridges are usually awkward, and still provide only restricted functionality. Both performance and safety can be enhanced through a tighter coupling between the data management and programming language facilities. It is this lack of a truly integrated system which provided our inspiration at Ontologic, Inc. This paper reviews Ontologic's VBASE Integrated Object System and describes how it combines language and database functionality.

Combinator-based compilation of recursive functions with different parameter passing modes

Wand's technique of deriving compilers from denotational semantics is applied to a block structured language with recursive functions. The emphasis is on compilation of different parameter passing modes and a simple storage management. The technique starts by eliminating λ-variables from semantic equations through the introduction of special-purpose combinators. The final code consists of combinators equivalent to target-machine instructions (running-system procedures). The method enables us to derive a compiler and a running system directly from the denotational semantics of a language.

Support for dynamic binding in strongly typed languages

Dynamic binding is a facility usually found only in weakly typed languages. A strongly typed, block-structured language can, however, also support dynamic binding if its implementation is modified according to a set of widely applicable principles. The result of applying these principles to a strongly typed base language is a language that has much of the flexibility of weakly typed languages without requiring extensive run-time type checking.The primary principles in this general approach to adding dynamic binding to a language are providing separate compilation for the units of dynamic binding, establishing a link between a name in one unit and its implementation in another, and assuring that programs using dynamic binding remain consistent during their execution. There are different methods for implementing each of these principles; two languages to which dynamic binding has been added serve to illustrate some of the alternatives.

Alternative Scope Rules for Block-Structured Languages

Alternative Scope Rules for Block-Structured Languages

Libraries as programs preserved within compiler continuations

An approach to library organization for block-structured languages is given that avoids corrupting such structuring with the introduction of “modules”, “units”, or “packages”. The scheme involves retentive block structuring and the preservation of partially compiled programs as compiler continuations. Its chief advantage is language simplicity. Its chief disadvantage is, at the present, its proclivity towards redundant file storage. This can possibly be eliminated by adopting a computational model using a one-level store.

On the complexity of recursion in problem-solving

The importance of paying attention to the complexity of recursion in problem solving is stressed. Many ill-founded beliefs and doctrines on constructing recursive algorithms are challenged. The Tower of Hanoi problem and its variant are used as concrete examples for illustrating that many seemingly correct recursive algorithms are, indeed, invalid or non-optimal. A simple context-free grammar for generating strings of balanced parentheses is then used to show the difficulty of programming recursive algorithms in block-structured languages. Other factors contributing to the difficulty in understanding recursive algorithms implemented in block-structured languages are also identified. It is suggested that more research needs to be done to foster the science of recursive programming.

A Simple Separate Compilation Mechanism for Block-Structured Languages

A very simple and efficient technique for the introduction of separate compilation facilities into compilers for block-structured languages is presented. Using this technique, programs may be compiled in parts while the compile-time checking advantages of compilation as a whole are retained. These features are simple for a programmer to understand and are easy to implement. Experience has shown this separate compilation mechanism to be a useful tool in the development of large programs in block-structured languages.