bluuebunny/crossref_metadata_2025 huggingface dataset:
Mixin-based inheritance
Authors: Bracha Gilad , Cook William
Published: November 2005

The diverse inheritance mechanisms provided by Smalltalk, Beta, and CLOS are interpreted as different uses of a single underlying construct. Smalltalk and Beta differ primarily in the direction of class hierarchy growth. These inheritance mechanisms are subsumed in a new inheritance model based on composition of
mixins,
or abstract subclasses. This form of inheritance can also encode a CLOS multiple-inheritance hierarchy, although changes to the encoded hierarchy that would violate encapsulation are difficult. Practical application of mixin-based inheritance is illustrated in a sketch of an extension to Modula-3.
Formalization of generics for the .NET common language runtime
Authors: Yu Dachuan , Kennedy Andrew , Syme Don
Published: November 2005

We present a formalization of the implementation of generics in the .NET Common Language Runtime (CLR), focusing on two novel aspectsof the implementation: mixed specialization and sharing, and efficient support for run-time types. Some crucial constructs used in the implementation are dictionaries and run-time type representations. We formalize these aspects type-theoretically in a way that corresponds in spirit to the implementation techniques used in practice. Both the techniques and the formalization also help us understand the range of possible implementation techniques for other languages, e.g., ML, especially when additional source language constructs such as run-time types are supported. A useful by-product of this study is a type system for a subset of the polymorphic IL proposed for the .NET CLR.
Extensional normalisation and type-directed partial evaluation for typed lambda calculus with sums
Authors: Balat Vincent , Di Cosmo Roberto , Fiore Marcelo
Published: November 2005

We present a notion of η-long β-normal term for the typed lambda calculus with sums and prove, using Grothendieck logical relations, that every term is equivalent to one in normal form. Based on this development we give the first type-directed partial evaluator that constructs %able to construct normal forms of terms in this calculus.
A logic you can count on
Authors: Dal Zilio Silvano , Lugiez Denis , Meyssonnier Charles
Published: November 2005

We prove the decidability of the quantifier-free, static fragment of ambient logic, with composition adjunct and iteration, which corresponds to a kind of regular expression language for semistructured data. The essence of this result is a surprising connection between formulas of the ambient logic and counting constraints on (nested) vectors of integers.Our proof method is based on a new class of tree automata for unranked, unordered trees, which may result in practical algorithms for deciding the satisfiability of a formula. A benefit of our approach is to naturally lead to an extension of the logic with recursive definitions, which is also decidable. Finally, we identify a simple syntactic restriction on formulas that improves the effectiveness of our algorithms on large examples.
A bisimulation for dynamic sealing
Authors: Sumii Eijiro , Pierce Benjamin C.
Published: November 2005

We define λ
seal
, an untyped call-by-value λ-calculus with primitives for protecting abstract data by
sealing
, and develop a bisimulation proof method that is sound and complete with respect to contextual equivalence. This provides a formal basis for reasoning about data abstraction in open, dynamic settings where static techniques such as type abstraction and logical relations are not applicable.
Local reasoning about a copying garbage collector
Authors: Birkedal Lars , Torp-Smith Noah , Reynolds John C.
Published: November 2005

We present a programming language, model, and logic appropriate for implementing and reasoning about a memory management system. We then state what is meant by correctness of a copying garbage collector, and employ a variant of the novel separation logics [18, 23] to formally specify partial correctness of Cheney's copying garbage collector [8]. Finally, we prove that our implementation of Cheney's algorithm meets its specification, using the logic we have given, and auxiliary variables [19].
A type system for well-founded recursion
Authors: Dreyer Derek
Published: November 2005

In the interest of designing a recursive module extension to ML that is as simple and general as possible, we propose a novel type system for general recursion over effectful expressions. The presence of effects seems to necessitate a backpatching semantics for recursion similar to that of Scheme. Our type system ensures statically that recursion is well-founded---that the body of a recursive expression will evaluate without attempting to access the undefined recursive variable---which avoids some unnecessary run-time costs associated with backpatching. To ensure well-founded recursion in the presence of multiple recursive variables and separate compilation, we track the usage of individual recursive variables, represented statically by "names". So that our type system may eventually be integrated smoothly into ML's, reasoning involving names is only required inside code that uses our recursive construct and need not infect existing ML code, although instrumentation of some existing code can help to improve the precision of our type system.
Precise interprocedural analysis through linear algebra
Authors: Müller-Olm Markus , Seidl Helmut
Published: November 2005

We apply linear algebra techniques to precise interprocedural dataflow analysis. Specifically, we describe analyses that determine for each program point identities that are valid among the program variables whenever control reaches that program point. Our analyses fully interpret assignment statements with affine expressions on the right hand side while considering other assignments as non-deterministic and ignoring conditions at branches. Under this abstraction, the analysis computes the set of all
affine relations
and, more generally, all
polynomial relations of bounded degree
precisely. The running time of our algorithms is linear in the program size and polynomial in the number of occurring variables. We also show how to deal with affine preconditions and local variables and indicate how to handle parameters and return values of procedures.
Note on semantics and optimization
Authors: Rosen Barry K.
Published: November 2005

When can an optimizing compiler reorder the evaluation of parts of an expression? Should the definition of a language permit reordering? A common micsonception about the relation between semantics and optimization is analyzed in two contexts: numerical programming in procedural languages and nonnumerical programming in very high level languages.
An implementation of on-conditions in LISP
Authors: Krall Edward J.
Published: November 2005

An implementation of interrupt handling facilities for LISP is described. Although simple and straightforward, the inclusion of these facilities into the language has been neglected. Thus LISP remains a second-generation language. The incorporation of PL/1-like on-conditions allows the user much greater control over the action of the LISP program, and enables him to trap conditions in data that would otherwise terminate the processor.
Job control languages as machine orientated languages
Authors: Gurski Aaron
Published: November 2005

Arguments are presented which demonstrate the equivalence of computers (both real and virtual) and programming languages. The machine which job control languages are equivalent to is shown to be a virtual one: operating systems. A suggestion is made that a high level, portable job control language is feasible, and some suggestions as to features of the language are made.
On a missing mode in ALGOL 68
Authors: Baecker H. D.
Published: November 2005

An ALGOL 68 mode with the effect of the PL/1 AREA attribute (both BASED & AUTOMATIC) is proposed. The advantages of the mode are presented, followed by an outline of the modifications that would be needed in the ALGOL 68 syntax and standard prelude. Finally, implementation problems and garbage-collection advantages and disadvantages are surveyed.
The Ackermann function in APL
Authors: Linden Theodore A.
Published: November 2005

A programming language - such as APL with the execute operator - will normally have an Ackermann rating of infinity if it can manipulate and repeatedly execute command strings with-in a single statement.
On extending Fortran control structures to facilitate structured programming
Authors: Meissner Loren P.
Published: November 2005

A number of preprocessors and other extensions of Fortran have been implemented recently, aimed at adding "disciplined" control structures to the language. In spite of wide variations in the details of these dialects, many common features can be perceived. This paper attempts to identify these common features, and to draw some conclusions concerning their relation to a possible future widely acceptable structured Fortran language.Several different kinds of altarnative and lterative structures are described, along with some of the ways they have been implemented. The use of internal procedures for top-down refinement is noted. Few, of the dialects include a general multiple level exit, although in principle thls feature is needed for structured programming. Use of labels seems to be preferable to any alternative way of implementing, this feature in Fortran.Because of the importance of compatibility with existing programs, and for other reasons, it is unlikely that the GO TO staterent will disappear from Fortran in the forseeable future. However. with the addition of new control structures it should be possible to develop processors that warn againtst certain particularly awkward usages of GO TO statements.Further efforts are recommended, including continued support of the ANSI X3J3 Fortran standards committee, and the establishment of a separate group charged with oredicting trends and making timely recommendations for future extensions to the language.
"Further critical comments on PASCAL, particularly as a systems programming language"
Authors: Conradi Reidar
Published: November 2005

There has recently been some controversy between Habermann and Lecarme & Desjardins on PASCAL in "Acta Informatica".This paper contains some more comments on PASCAL, from a systems programmer's point of view.Some undefined points in PASCAL are first treated. Then PASCAL's data types are critically reviewed. A few remarks on common PASCAL constructs are also given.Since the author has experience with the programming language MARY, some comparisons between PASCAL and MARY will be made.
A survey of control structures in programming languages
Authors: Fisher David A.
Published: November 2005

The control structure of programming languages and their development are examined. Languages studied range from machine and assembly languages to procedure and problem-oriented languages. The emphasis, however, is on the control structures themselves, whether in current languages or proposed. Both implicit global interpretation rules for programming languages and explicit control operations are discussed. Many control structures developed through specialization from a small set of primitive sequential control operations. Specific control structures and mechanisms examined include activities, broadcast control, conditionals, constraint expressions, coroutines, critical sections, distributive operators, dynamic instruction modification, expressions, generators, implicit coroutines, implicit sequencing, iterative control, indivisibility, interleaved execution, the go to, macros, multipass algorithms, multiple sequential control, mutual exclusion, mutual subroutines, nonbusy waiting, nondeterministic control, open subroutines, parallel assignments, parallel processing, procedures, pseudo-parallel control, recursion, reentrant code, relative continuity, semaphores, sequential controls, shared procedures, simultaneous assignments, statements, subroutines, synchronization, syntax macros, time sharing, and back tracking.
Eliza in SNOBOL4
Authors: Duquet Robert T.
Published: November 2005

When implemented in Snobol4, Eliza is dramatically shorter and simpler than the original Fortran program. The brevity of the rewritten Eliza greatly enhances its value in a course on artificial intelligence. The complete program, and a portion of a script are included as Appendices.
Empirical comparison of LR(k) and precedence parsers
Authors: Horning J. J. , Lalonde W. R.
Published: November 2005

Knuth's LR(k) algorithm provides a more general basis for the syntactic portion of compilers than does precedence analysis. We have conducted experiments to determine, for practical grammars, how much this extra generality costs in efficiency. The results indicate that the extra generality of the LR(k) approach may often be accompanied by a reduction in table size and an increase in parsing speed.
A generalization of APL array-oriented concept
Authors: Charmonman S.
Published: November 2005

One of the most important concepts in APL is that standard scalar dyadic functions may be extended element-by-element to compatible structures. This paper presents a new definition of compatability which is a generalization of the APL array-oriented concept. Examples of programs in the generalized version are given with comparisons to standard APL, FORTRAN, ALGOL, and PL/1.
A machine-oriented recognition algorithm for context-free languages
Authors: Floyd Robert W.
Published: November 2005

A variant of the Cocke-Younger algorithm for recognition of context-free languages permits faster operation by a factor proportional to word length on computers with parallel bit-manipulation capabilities.
Bounce-and-skip
Authors: Nievergelt J. , Irland M. I.
Published: November 2005

A new technique for directing the flow of control in block structured programs is described. It allows a programmer to delay using the outcome of a test indefinitely, and to make the entry and exit of begin-end blocks conditional upon the last test performed. This technique is the main tool for directing the flow of control in the programming language Nucleol, and is considered to be particularly useful for program debugging.
Optimization aspects of compiler-compilers
Authors: Cheatham Thomas E. , Standish Thomas A.
Published: November 2005

A decade of experience with prototype versions of compiler-compilers, some of which have been successful and some of which have not been so successful, leads us to the conclusion that we can now engineer good compiler-compilers which can generate efficient compilers that generate efficient object code. This paper reviews the experience with compiler-compilers, documents reasons for believing that some compiler-compilers are good, and advocates the importation of compiler-compiler techniques by commercial firms and the production of well-engineered compiler-compilers as commercial products. Some unanswered questions about compiler-compiler techniques are explored in relation to the newly emerging discipline of software engineering.
Some delitescent concepts in computer architecture
Authors: Lindamood George E.
Published: November 2005

As someone has said, "If things weren't as they are, they would be different." With that in mind, I began to think about why some things are as they are in computer architecture. I tried to imagine what things would be like if something were bigger or smaller or if the reverse or obverse of some situation or concept were operant. What I came up with were a few ideas in the vein of the "COME FROM" statement in programming languages.
1
Perhaps they will set you to thinking, too.
The META/REDUCE translator writing system
Authors: Marti Jed
Published: November 2005

The META/REDUCE translator writing system operates in a LISP environment closely interfaced with both LISP and REDUCE syntax. The language supports: BNF like syntax, recursive descent parsing schemes, lexical primitives, symbol table primitives, and automatic syntax error message generation. A complete simple arithmetic expression evaluator provides an introduction to the capabilities of the system. The body of the work describes the control constructs and primitives of the system. The paper is completed with the description of a working interpreter for a subset of a contemporary programming language. It is assumed that the reader has some familiarity with LISP 1.5 and REDUCE.
Parameter validation for software reliability
Authors: Alleman Glen B.
Published: November 2005

This paper presents a method for increasing software reliability through parameter validation. Existing systems are examined and a proposed technique is presented to aid in the static parameter validation of RATFOR programs.
Language design for the Ironman requirement
Authors: Shaw Mary , Hilfinger Paul , Wulf Wm. A.
Published: November 2005

Tartan is an experiment in language design. The goal was to determine whether a "simple" language could meet substantially all of the Ironman requirement for a common high-order programming language.We undertook this experiment because we believed that all the designs done in the first phase of the DOD effort were too large and too complex. We saw that complexity as a serious failure of the designs: excess complexity in a programming language can interiere with its use, even to the extent that any beneficial properties are of little consequence. We wanted to find out whether the requirements inherently lead to such complexity or whether a substantially simpler language would suffice.Three ground rules drove the experiment. First, no more than two months -- April 1 to May 31 -- would be devoted to the project. Second, the language would meet all the Ironman requirements except for a few points at which it would anticipate Steelman requirements. Further, the language would contain no extra features unless they resulted in a simpler language. Third, simplicity would be the overriding objective.The resulting language, Tartan, is based on all available information, including the designs already produced. The language definition is presented here; a companion report provides an overview of the language, a number of examples, and more expository explanations of some of the language features.We believe that Tartan is a substantial improvement over the earlier designs, particularly in its simplicity. There is, of course, no objective measure of simplicity, but the syntax, the size of the definition, and the number of concepts required are all smaller in Tartan.Moreover, Tartan substantially meets all of the Ironman requirement. (The exceptions lie in a few places where we anticipated Steelman requirements and where details are still missing from this report.) Thus, we believe that a simple language can meet the Ironman requirement. Tartan is an existence proof of that.We must emphasize again that this effort is an experiment, not an attempt to compete with DOD contractors. Tartan is, however, an open challenge to the Phase II contractors: The language can be at least this simple! Can you do better?
Language design for the Ironman requirement
Authors: Shaw Mary , Hilfinger Paul , Wulf Wm. A.
Published: November 2005

The Tartan language was designed as an experiment to see whether the Ironman requirement for a common high-order programming language could be satisfied by an extremely simple language. The result, Tartan substantially meets the Ironman requirement. We believe it is substantially simpler than the four designs that were done in the first phase of the DOD-1 effort. The language definition appears in a companion report; this report provides a more expository discussion of some of the language's features, some examples of its use, and a discussion of some facilities that could enhance the basic design at relatively little cost.
Coroutines in FORTRAN
Authors: Skordalakis E. , Papakonstantinou G.
Published: November 2005

A method is described for using coroutines within the strict confines of ANSI FORTRAN. A FORTRAN preprocessor that has been implemented to transform FORTRAN programs, written as if coroutines were allowed, to standard ANSI FORTRAN programs is also described.
Toward efficient programming in virtual systems
Authors: Holton John B.
Published: November 2005

An approach to improving the processing efficiency of COBOL programs executed on virtual storage systems is suggested. The approach uses program manipulation and system information facilities in solving the problem.
A note on procedure timing
Authors: Crowley Charles , Klimowicz Gary
Published: November 2005

Procedure timing is important in program performance improvement. The feasibility of such timings is discussed in relation to commonly used computers and operating systems. Some simple design criteria are described which facilitate such timing in an operating system. Finally, some observations are made on how clocks might be made available at the hardware level to further facilitate procedure timing.
On the semantics of control statements
Authors: Nead James M.
Published: November 2005

The problem of programming language semantics is viewed from a new perspective, in which the notion of process (defined as a partial ordering of events) is taken as fundamental and the notion of state is derivative. This type of semantics is seen to be compatible with the algebraic definition of data types. A statement of a program is taken to be an axiom of an abstract process, which in turn represents a real execution of the program. The method is found to be useful in discussing the nature of program control, especially concurrent processes.
Some inconsistencies in programming language implementation
Authors: Salvadori Antonio , Dumont Christine
Published: November 2005

In this short correspondence, attention is drawn to the inconsistency in the present implementation of Boolean expressions. A solution is suggested that would generate more meaningful and optimised code.
Control flow complexity and structuredness of programs
Authors: Srinivasan B. , Gopalakrishna V.
Published: November 2005

This paper describes a procedure to automatically restructure the programs in order to reduce the control flow complexity.
The cyclomatic number and the normal number of programs
Authors: Culik Karel
Published: November 2005

The cyclomatic number of a program = flow graph = flow diagram = program scheme is its number of tests, without any respect to the existence or non-existence of loops. The normal number of a program is the (minimal) number of loops in a normal form of the program. The running time of a program is one of the most important complexity measures which is reflected by the normal number but not by the cyclomatic number.
A multi-task system for robot programming
Authors: Gini Giuseppina , Gini Maria , Gini Renato , Giuse Dario
Published: November 2005

In this paper we discuss issues of design for software systems for computer controlled manipulators.The aim of the paper is to present the experience obtained in designing and implementing MAL, a stand-alone software system for controlling and programming a two-arms manipulator.That system supplies the user a simple multi-task programming language, with a BASIC-like external form, and operating instructions for compiling, executing, editing and saving the program.We will emphasize how management of multiprocess capabilities, synchronization of different devices, error handling and other desirable features can be inserted in a simple system, implemented on a small minicomputer, suitable for industrial applications.
Micro Extensible Programming Language
Authors: Smart Robert K.
Published: November 2005

This paper describes Micro Extensible Programming Language, a language designed to show how almost all the constructs of a major language like ALGOL 68 can be developed in a language which has procedure call and return as its only control structure. The user can and must define his own primitive modes and objects, there being none built in. It is shown how the modes and procedures thus defined form a Category in the modern mathematical sense.
Preliminary ZENO language description
Authors: Ball J. E. , Williams G. J. , Low J. R.
Published: November 2005

The specification of ZENO, a programming language intended as the target language for a research project in advanced compiling, is presented. The language is strongly based on EUCLID, with modifications for message-based parallel processing and a somewhat different treatment of data types.
Application of a remote code generator
Authors: Pflasterer David C.
Published: November 2005

Previous work has shown that quality software can be produced by deferring the machine code generation portion of a compiler until a program has been tested and known to be production worthy. In this approach an interpreter is used to facilitate testing and the creation of fault tolerant programs. A machine code generator, then applied to tested programs, preserves fault tolerance and provides efficiency.The application of this unique approach to fault tolerant programming, which places the machine code generator remote from the lexical and semantic portions of the compiler, will be examined in this paper. Covered will be 1) the generation of code which preserves fault tolerance: 2) the code optimization techniques employed to produce the necessary efficiency; and 3) the results of implementing this approach into a production environment.
A language for computational algebra
Authors: Jenks Richard D. , Trager Barry M.
Published: November 2005

This paper reports ongoing research at the IBM Research Center on the development of a language with extensible parameterized types and generic operators for computational algebra. The language provides an abstract data type mechanism for defining algorithms which work in as general a setting as possible. The language is based on the notions of
domains
and
categories
. Domains represent algebraic structures. Categories designate collections of domains having common operations with stated mathematical properties. Domains and categories are computed objects which may be dynamically assigned to variables, passed as arguments, and returned by functions. Although the language has been carefully tailored for the application of algebraic computation, it actually provides a very general abstract data type mechanism. Our notion of a category to group domains with common properties appears novel among programming languages (cf. image functor of RUSSELL) and leads to a very powerful notion of abstract algorithms missing from other work on data types known to the authors.
Structured programs in PL/I
Authors: Kylov Haim I. , Nudelman S.
Published: November 2005

This paper contains examples of structured PL/I programs. For a number of years these programs were assigned to LGU students majoring in economics/math in their programming classes.This paper is designated for students and other people studying programming.
The case for BUFFERS in SNOBOL4
Authors: Duff Steven G.
Published: November 2005

Two articles have appeared recently in SIGPLAN Notices describing the "Great Big Substitution Problem" of SNOBOL4 pattern matching [BLAT80, SCHI81]. Although the proposals in these papers are different, they both suggest the addition of new operators to the language to solve the problem. The purpose of this paper is to show that the Great Big Substitution Problem is embedded in a problem of a more pervasive nature, and to suggest a correspondingly more general solution.
A basis for the rate of change in programs
Authors: Payne A. J.
Published: November 2005

This paper shows how the OR technique of the Mean Path Theorem can lead to results that indicate the rate of change of a program structure. We have compared with other theoretical results and found that it is consistent with the same order of magnitude.
A note on enumerations
Authors: Gladney H. M.
Published: November 2005

The design of the enumeration data type is known to be imperfect in both PASCAL and ADA. A new design which avoids the known problems is proposed. An implementation in the experimental programming language CONCISE confirms the design.
EPILOG = PROLOG + Data Flow
Authors: Wise Michael J.
Published: November 2005

Spurred by the desire to construct multi- processor computer architectures, researchers have been proposing alternatives to the conventional wisdom of the Von Neumann design. One of the most Interesting and innovative of these is the class of machines based on the principle of data-flow - the order in which data-flow operations are executed is dependent solely on the availability of input data. The results of experiments with both real and simulated data-flow computers have, however, been rather less than earth shattering. It is the thesis of this work that PROLOG contains within it the seeds of a solution for the difficulties found in data-flow.The material contained in this work is a revision and substantial expansion of sections 2 and 3 of [Wise 82].
Nestable bracketed comments
Authors: Weinman Joseph B.
Published: November 2005

A comment syntax is proposed that is the logical evolution of a widely used comment style. The impact on the compilation process is also discussed.
Enhanced input/output on Pascal
Authors: Burns A.
Published: November 2005

Pastal is a collection of language features aimed at improving the programming of dialogue in a Pascal type language. It is not a comprehensive collection as Pastal is an experimental language. Dialogue in Pastal takes the form of an active comment attached to an executable (usually read) statement. Execution of the statement causes the dialogue to be displayed. Associated with the application program is a direct access file providing extra 'help' text for users in difficulty. A mechanism for giving controlled and easy access into this file is contained in Pastal.
On the application of Rothon diagrams to data abstraction
Authors: Brown E. J.
Published: November 2005

The technique of flowcharting proposed by Rothon [ROT79] (called Rothon diagrams throughout this paper) and the technique of Data Abstraction proposed by Parnas [PAR72a], [PAR72b], [PAR76] are briefly discussed along with other work that is relevant to program design. The outline of a method for utilizing these techniques to produce a top level machine testable design is presented.
An algebraic specification of a Pascal compiler
Authors: Despeyroux Joëlle
Published: November 2005

There is a growing interest in abstract data types as a tool for specifying semantics of programming languages and for specifying translations. This paper present the first large scale experience in this area. An algebraic semantics of Pascal, using abstract data type is given. Then an algebraic semantics of the low-level language P-Code is given. Finally a specification of a compiler from Pascal to P-Code, by means of implementation of abstract data types, is given, with a small example of translation.
A walk through AWK
Authors: Levy Leon S.
Published: November 2005

This tutorial on AWK is intended for readers who have a general familiarity with UNIX*, and who have at least a rudimentary knowledge of programming in some procedural language.AWK is an interpretive programming language, which makes it useful for prototyping. Primary applications of AWK are information retrieval, report writing, and data manipulation.AWK is often used as a special purpose information processing language - many of whose capabilities are easily accessible to non-programmers. We present it as a programming language - with added capabilities - particularly useful for rapid prototyping.
Comparing two definitions for the notion "data type"
Authors: Greiter Gebh
Published: November 2005

Perkins (see /Prkns/) compared three papers defining the notion "data type": /Guttg/, /Gougn/, and /Greit/. He came to the conclusion that /Guttg/ is a paper investigating the question of consistency and completeness of data type specifications to a sufficiently large extent, and he concludes that, therefore, there is no need for a type theory that is not based on the theory of initial algebras.
Language features to support reusability
Authors: Spector David
Published: November 2005

Current programming languages have not been designed to support reusability as a primary goal. The purpose of this note is to analyze the requirements imposed by reusability and some of the consequent implications for language design. Recommendations are made for particular language features to help meet these requirements. The whole exercise is offered as an example to be improved upon, not as a final answer to the problem of language support for reusability.
Optimizing loops in programs compiled with the IBM PL/I optimizing compiler
Authors: Brownsmith Joseph D. , Oliver Leslie H.
Published: November 2005

This paper investigates the effect that a PL/I programmer's PL/I coding decisions can have on execution time efficiency. Specifically, we investigated the conditions under which the IBM PL/I optimizing compiler Release 4.0 [2] would produce optimized code for loops. We used several different coding styles to express the same algorithm and examined the code generated by the compiler. We also executed the code and measured its cpu time requirements. The optimized code executed 5 times faster than non-optimized code for the example chosen. We found that optimization was inhibited by not specifying both optimize (time) and reorder. It was further found that programmer decisions such as the use of based variables or user-defined functions in the loop can also inhibit optimization.
String-handling facilities of the LSE language
Authors: Noyelle Yves
Published: November 2005

After a brief presentation of the general purpose LSE language, this paper describes its powerful string-handling facilities for text analysis and manipulation.
A Program Design Language for software engineering
Authors: Woodman Mark
Published: November 2005

Program Design Languages have been used for some time in the informal description of software and as an aid to top-down program construction. In general, such languages have not been amenable to the automatic generation of project management information (such as module interconnection details and complexity measurements) useful in the software engineering process. This paper reviews the characteristics of existing program design languages and suggests a new notation and tool for its manipulation.
The coroutines of Hanoi
Authors: Birtwistle Graham
Published: November 2005

We present a non-recursive solution to the towers of Hanoi in which each each disk is represented as a coroutine with a very simple action history.
SARTEX a programming language for graph processing
Authors: Breguet Pierre , Grize Francois , Strohmeier Alfred
Published: November 2005

SARTEX [1] is a programming language, designed especially for graph processing, which belongs to the PASCAL [2] family of languages. A compiler written in PASCAL which generates PASCAL code has been developed. In addition to the usual data types, the language provides the predefined types VERTEX, ARC and GRAPH. Objects can be organized in dynamic structured types named
stack, list, set
and
array
. For visiting the elements of a structured object, the usual statements are completed by the instruction "
forall
...
in
...
do
...". Inputs and outputs can be processed interactively or with sequential files as data. The language also directly supports the drawing of graphs on a graphic device.
Improving Gough's LL(1) lookahead generator
Authors: Dwyer Barry
Published: November 2005

Gough's application of the Eve and Kirki-Suonio algorithm to generating the lookaheads for an LL(1) grammar is a big improvement on its forerunners. Gough's method is fast, but it is still capable of improvement. For a typical grammar, it is possible to reduce its space and time requirements by about one half.
Threaded interpretive systems and functional programming environments
Authors: Glass Harvey
Published: November 2005

While languages based upon threaded interpretive systems have been used for a variety of applications, these systems have been generally ignored by serious students of programming languages. We describe research here at the University of South Florida where we are investigating the suitability of these systems for implementing a programming environment - specifically an environment to support programming in a functional style.We hypothesize that threaded interpretive systems may have merit as the basis for more ambitious language implementations than have yet been attempted - and that such languages may offer a reasonable compromise between the flexability of more interpretive systems and the efficiency of compilers that generate native code. We describe extensions to a threaded language which provide the kernel of a functional style language. Our goal is to gain insight into the real and apparent capabilities of threaded languages and to evaluate the potential of such systems for support of functional programming environments.
Pascal and comms programming
Authors: Jonak Jan E.
Published: November 2005

Complex architectures of specialised processors are not always easily amenable to high level language programming without having to pay high price in terms of poor resources utilisation or lengthy custom language design and compiler development process.This paper describes Pascal-F, an attempt at a minimal modification of the widely accepted language Pascal to achieve close match between source and object code in a specialised communications processor and to make possible transportation of at least some of subsequently developed software to more conventional hardware.
Programming language assessments using the program profiles
Authors: Sklenar Ivan
Published: November 2005

There is a number of comparisons of various programming languages, but there is only a limited number of comparisons based on the quantitative assessement (Perrit, Dhillon, 81). This paper provides the comparison of some Algol 68 features with similar features in other languages e.g. Pascal and Ada. The comparison is based upon the statistics (profiles) of Algol 68 programs. Terms used in this paper come rather from general programming languages background than from particular Algol 68 terms. Special features and necessary Algol 68 terms are explained in the text. The most significant results: 25 per cent of IFs are conditional expressions, constant declarations are more frequent than variable declarations.
A new method of generating LL(1) lookahead sets
Authors: Gough K. John
Published: November 2005

The purpose of this note is to draw attention to the existence of a new, efficient algorithm for generating the LL(1) lookaheads for the productions of a context-free grammar. The algorithm is related to a classical method, but forms the sets First() and Follow() directly, rather than first forming the inverses.The success of the method depends on the application of an algorithm which forms a set-union on the transitive closure of a relation. This algorithm is the same one used in the DeRemer and Pennello algorithm for generating the LALR lookaheads for bottom-up parsers.A fuller account of the algorithm and its implementation is available in a technical report, Gough [1984].
M'PAL
Authors: Rosenbloom Michael H.
Published: November 2005

This paper investigates a programming language in which one states one's program as a single imperative sentence and then supplies the compile with a collection of definitions, such as one would find in Webster's dictionary. The compiler would then supply the control flow needed to unify the definitions into a program. The objective was to discover the salient features such a compiler would have to have --- in particular, whether a programming language based on this style of programming might be more natural a way to eliminate control flow than production systems or PROLOG are.
Internal representation of programs in GRASE
Authors: Albizuri-Romero Miren Begoña
Published: November 2005

A program written in a programming language can be broken down into syntactic components which are related by syntactic rules governing the language. Syntax-directed editors are editors which know and use the syntax of the language while editing a program. While text editors treat programs as text, syntax-directed editors use the underlying syntax of the programming language. A program is stored as an abstract syntax tree that is built by the editor from constructive commands issued by the programmer and the node depth level is the structure level in the program. The elements of the concrete representation of languages, such as keywords, punctuation marks, separators, terminators, etc. are not kept in the tree.
The trouble with mutual recursion in Concurrent Euclid
Authors: Gerber A. J.
Published: November 2005

The author relates how he squandered a day's work trying to bend a compiler to his needs, and how the resulting solution became equally bent. A working knowledge of Concurrent Euclid is not necessary to understand this paper.
Some ramifications of the EXIT statement in loop control
Authors: Whitelaw M. W.
Published: November 2005

EXIT statements support a style of programming that distinguishes between the control operations and the actions in a loop. Readability suggests that multiple EXIT statements are preferable to a single EXIT statement in a loop with multiple invariants. This is particularly true if implementational considerations have confused the neatness of the loop termination condition.
Cheap concurrency in C
Authors: Binding Carl
Published: November 2005

This paper describes the implementation of a simple kernel providing concurrency for the C programming language
1
. The kernel provides services for process creation and termination, process synchronization, handling of interrupts, and mutual exclusion. It runs under UNIX
2
(bsd 4.2) and is almost entirely implemented in C([2]).
The design and implementation of a flexible retrieval language for a Prolog database system
Authors: Hornsby C. , Leung C. H. C.
Published: November 2005

This paper describes the design and implementation of a data retrieval language for a Prolog-based database system. The language itself is implemented in Prolog, and it forms part of a more comprehensive project to build an intelligent database system which incorporates deductive capabilities, enforcement of integrity constraints, and automatic normalisation. Among the features of the language are the use of the common relational operators such as Select, Project, and Join, and the incorporation of built-in functions such as Counting and Averaging. Although the language is not relational complete, actual user experience indicate that it is much more powerful than the native Prolog query interface, and it provides a versatile enhancement to the database capability of Prolog.
Program editors should not abandon text oriented commands
Authors: Waters Richard C.
Published: November 2005

In the past few years, a number of program structure editors have appeared. These editors provide a number of very useful commands which interact with a program viewed as a parse tree. Unfortunately, rather than just adding these commands to those already available, these editors have typically eliminated all (or most) text oriented commands. As a result, the users are forced to use the structure oriented commands all (or most) of time whether they want to or not.This note argues that text oriented commands are very useful and should be retained. There is no reason why a program editor cannot support both text and structure commands.
A new LALR formalism
Authors: Park J. C. H.
Published: November 2005

A new formalism pertaining to LALR analysis is described which serves the dual purpose of providing efficient algorithms and of facilitating their correctness proofs.
How to print with style
Authors: Gladney H. M.
Published: November 2005

Embedded format controls limit the reusability of programs. The problem is examined using a stream output example. It may be avoided if a map from data types to formatting options is passed to output service routines instead of a list of specific formats. Such a map is here called a "style".This concept can be used with any programming language. However, it is most natural in the context of a language which offers data abstractions and user-defined generic operators. CONCISE is an experimental programming language in use to test the effectiveness of these technologies. CONCISE programs exploiting styles show how they help make program reusability feasible. As a byproduct, output formating becomes more flexible than it is with current approaches.
The EPN and ESN notations
Authors: Elliott Irving B.
Published: November 2005

Two specification notations are introduced:(1) An Executable Program Notation (EPN) that can be used either for specifying procedural coding or can serve as an intermediate language produced from a higher-order language. The notation is configured such that it can either be executed interpretivelly, or be easily converted into executable coding.(2) An Executable Syntax Notation (ESN) for specifying the syntax of a higher-order language; the notation is configured such that it can either be executed interpretivelly as the parser of a compiler for the specified programming language, or be easily converted into EPN or other executable coding.Examples of EPN and ESN are given, as well as examples of the conversions of Boolean expressions into EPN procedures for the evaluation of the expressions and the conversion of ESN into EPN procedures to perform parsing.
Efficient computation of LALR(1) look-ahead sets
Authors: Pennello Thomas J. , DeRemer Frank
Published: November 2005

We define two relations that capture the essential structure of the problem of computing LALR(1) look-ahead sets, and present an efficient algorithm to compute the sets in time linear in the size of the relations. In particular, for a PASCAL grammar, our algorithm performs less than 20% of the set unions performed by a popular compiler-compiler (YACC).
MR
Authors: Minimair Manfred
Published: November 2005

The software package MR for Maple, Versions 7 and 8, contains an implementation of Macaulay's algorithm for computing the dense multi-variable resultant ([?], [?]) of a list of multivariate polynomials. An extended list of some of the features is:• Designed independently from the coefficient ring of the input polynomials.• Optimized for polynomials with coefficients being integer polynomials.• Optionally computes generalized characteristic polynomials.• Optionally self-profiling (timing, tracing).• Well integrated with Maple's Linear Algebra package.• Designed to emulate overloading, according to the type of the input, of the main sub-functions, while not sacrificing efficiency.It is important to point out that there are other resultant packages available for Maple (see e.g. [?], [?], [?]). However, they do not provide the full range of features of the current package, MR, and they are not designed for the most recent versions of Maple. Therefore the author believes that the current package is of great interest to the symbolic computation community.
Usage:
We briefly describe how the package MR is to be used in Maple. The main function, exported by the package MR, is called asMR:- MResultant (plist, vlist, options);The input argument "plist" is a list of not necessarily homogeneous polynomials. The variables of these polynomials are contained in the list "vlist". The symbol "options" stands for a sequence of optional arguments. These optional arguments are described in detail in http://minimair.org/MR.mpl. If called without optional arguments, the main function returns the Macaulay (multi-variable) resultant of the polynomials in "plist" with respect to the variables in "vlist".