bluuebunny/crossref_metadata_2025 huggingface dataset:
Using Ada for industrial embedded microprocessor applications
Authors: Duncan A. G. , Hutchison J. S.
Published: November 2005

This paper investigates the use of Ada as a high level implementation language for use on microprocessors embedded in industrial applications. Many of these applications use microprocessors with minimal hardware, that is, no hardware support for a stack and possibly not even a hardware clock. The use of minimal hardware is dictated by manufacturing economics. If one can save $.25 per unit over a run of 100,000 units, the total savings will be $25,000. An Ada implementation for such hardware will differ greatly from an implementation for a large mainframe. For instance, the storage allocator cannot blithely allocate space for variables in activation records. While these programs do not use many of Ada's powerful language features, the compiler must be able to generate highly optimized code for those parts of the language that are used.Our discussion of Ada centers around a typical application, a program to control an automatic oven. While this example is not one of our intended applications, it embodies most of the problems that we expect to find in practice. The example was inspired by McCracken's furnace control case study [1], written in PL/M, and provides a good opportunity for comparing Ada with PL/M.Applications like the oven control program require a number of sophisticated compiler optimizations. In addition to performing the usual common subexpression analysis, removal of redundant and unreachable code, and sophisticated peephole optimizations, the compiler must be capable of complete static allocation of all data and must be able to perform significant amounts of verification to simplify generated code, especially with respect to error checks and exception handling.Finally, we discuss some language problems and some programs that we feel are necessary for use of Ada in real-time and time-dependent situations.
A practical method of documenting and verifying Ada programs with packages
Authors: Luckham David C. , Polak Wolfgang
Published: November 2005

We present a method of formal specification of Ada programs containing packages. The method suggests concepts and guidelines useful for giving adequate informal documentation of packages by means of comments.The method depends on (1) the standard inductive assertion technique for subprograms, (2) the use of history sequences in assertions specifying the declaration and use of packages, and (3) the addition of three categories of specifications to Ada package declarations: (a) visible specifications, (b) boundary specifications, (c) internal specifications.Axioms and proof rules for the Ada package constructs (declaration, instantiation, and function and procedure call) are given in terms of history sequences and package specifications. These enable us to construct formal proofs of the correctness of Ada programs with packages. The axioms and proof rules are easy to implement in automated program checking systems. The use of history sequences in both in formal documentation and formal specifications and proofs is illustrated by examples.
ANNA
Authors: Krieg-Brückner Bernd , Luckham David C.
Published: November 2005

A
NNA
is a proposal to extend Ada to include facilities for formally specifying the intended behaviour of Ada programs (or portions thereof) at all stages of program development. A
NNA
programs are Ada programs with formal comments. Formal comments in A
NNA
consist of virtual Ada text and annotations. The syntax and semantics of different kinds of annotations are defined: declarative annotations (for variables, subtypes, subprograms, and packages), statement annotations, exception annotations, and visibility annotations. A
NNA
includes a small number of predefined attributes which may appear only in annotations, e.g., access type collections.The lexical structure of A
NNA
is designed so that the extensions of Ada appear as Ada comments. A
NNA
programs are therefore acceptable by Ada translators. The semantics of annotations are defined in terms of Ada concepts, in particular many annotations are generalization of the constraint concept. It is therefore a simple step for the Ada programmer to use A
NNA
to give formal specifications of programs.A
NNA
is intended to provide a formal framework within which different theories of formal specification may be applied to Ada. Our proposal omits tasking for the time being.
Nesting in Ada programs is for the birds
Authors: Clarke Lori A. , Wileden Jack C. , Wolf Alexander L.
Published: November 2005

Given a data abstraction construct like the Ada package and in light of current thoughts on programming methodology, we feel that nesting is an anachronism. In this paper we propose a nest-free program style for Ada that eschews nested program units and declarations within blocks and instead heavily utilizes packages and context specifications as mechanisms for controlling visibility. We view this proposal as a first step toward the development of programming methods that exploit the novel language features available in Ada. Consideration of this proposal's ramifications for data flow, control flow, and overall program structure substantiates our contention that a tree structure is seldom a natural representation of a program and that nesting therefore generally interferes with program development and readability.
Algorithms for translating Ada multitasking
Authors: Stevenson D. R.
Published: November 2005

Algorithms are presented for translating the multitasking constructs of Ada into the language Ada-M. The purpose of the translation is to study various implementations of Ada tasking and their relative problems, merits, and efficiencies. The multiprocessing constructs of Ada-M are lower level than those of Ada and, hence, flexible enough to permit development of a variety of compilation techniques for Ada tasking. Ada-M is sufficiently high-level, however, to permit the implementations to be developed quickly and Understandably. Requirements for data structures, scheduling, and other pertinant elements of Ada tasking compilation are identified by the translation.
The design of a virtual machine for Ada
Authors: Groves L. J. , Rogers W. J.
Published: November 2005

An implementation of Ada should be based on a machine-independent translator generating code for a Virtual Machine, which can be realised on a variety of machines. This approach, which leads to a high degree of compiler portability, has been very successful in a number of recent language implementation projects and is the approach which has been specified by the U. S. Army and Air Force in their requirements for Ada implementations.This paper discusses the rationale, requirements and design of such a Virtual Machine for Ada. The discussion concentrates on a number of fundamental areas in which problems arise: basic Virtual Machine structure, including storage structure and addressing; data storage and manipulation; flow of control; subprograms, blocks and exceptions; and task handling.
A syntax for character and string constants supplying user-defined character codes
Authors: Pentzlin Karl L.
Published: November 2005

The author proposes a syntactical construct to give the user control over the character code which maps character and string constants to their binary values.In doing so, the author proposes a syntax for character and string constants that provides- clear distinction of characters and strings of size 1- easy handling of non-printable characters- increased readability of the source code.
An alternative to the communication primitives in ADA
Authors: Stroet Jan
Published: November 2005

A critical look is taken at the ADA communication primitives by comparing them to the ITP (Input Tool Process) model, the model for process communication developed at Nijmegen. The comparison is done by means of example solutions to several problems in both models.It is shown that by using features extracted from the ITP model, the communication facilities in ADA could be improved considerably with respect to orthogonality, clarity, flexibility and power.
Meeting on melpomenes
Authors: Levy Michael
Published: November 2005

This story has been used with success at third year and graduate levels to generate some philosophical interest in students in issues related to data types.
A note on the distributed program component cell
Authors: Silberschatz Abraham
Published: November 2005

This paper presents a new language construct for distributed computing. This construct, called cell, allows one to simulate a variety of language constructs. Its salient features provide the programmer with an effective synchronization scheme, and a mechanism to control the order in which various activities within a cell should be executed.
A solution to the great big substitution problem
Authors: Schilit Bill N.
Published: November 2005

In a recent SIGPLAN article [1] a major deficiency in the SNOBOL4 programming language was exposed and one possible solution suggested. The SNOBOL4 language shortcomming, dubbed "the great big substitution problem", involves replacing substrings in the subject string. This article describes an alternative modification to SNOBOL4, which allows replacement of a matched substring of the subject during pattern matching, along with some ideas on implementation.
Application of the goal invariant to the structuring of programs
Authors: Laski Janusz W.
Published: November 2005

Functional rather than structural approach to conversion of a two-exit loop into a while loop is presented. The functions computed by the corresponding exits are formally specified and their union is analyzed to reveal the cause of its loop nonrealizability. The latter is removed by either redefining the domain/range of the constituent functions or by inclusion of the loop postludes into the loop specification. None of these methods changes the functionality of the original program because no new variables are introduced.
Classes
Authors: Stroustrup Bjarne
Published: November 2005

Language constructs for definition and use of
abstract data types
ease the design and maintenance of large programs. This paper describes the C
class
concept, an extension to the C language providing such constructs. A class is defined using standard C data types and functions, and it can itself be used as a building block for new classes. A class provides a way of restricting access to a data structure to a specific set of functions associated with it, without incurring significant overheads at compile time or at run time.The C class concept is introduced by small examples of its use, and familiarity with the C language [2] is assumed. Appendix A is a complete small C program using classes.Classes have been in use for more than a year on a dozen PDP11 and VAX UNIX systems [1], and they are currently used for a diverse set of projects on more than 30 systems. Classes are currently implemented by an intermediate pass of the
cc
compiler, called the class pre-processor, which is invoked when the directive
#class
is found in a C source file. The class pre-processor is easily ported to a system with a version of the portable C compiler. A Motorola68000 version is in use.
A software debugging glossary
Authors: Johnson Mark Scott
Published: November 2005

This glossary contains 291 definitions of terms dealing with the debugging of computer software. The list includes numerous synonyms, as well as the proper names of debugging systems described in the open literature. Terms and definitions have been obtained from various sources: the software-engineering literature, other software-engineering glossaries, and individual contributions.
A theory of small program complexity
Authors: Magel Kenneth
Published: November 2005

Small programs are those which are written and understood by one. person. Large software systems usually consist of many small programs. The complexity of a small program is a prediction of how difficult it would be for someone to understand the program. This complexity depends of three factors: (1) the size and interelationships of the program itself; (2) the size and interelationships of the internal model of the program's purpose held by the person trying to understand the program; and (3) the complexity of the mapping between the model and the program. A theory of small program complexity based on these three factors is presented. The theory leads to several testable predictions. Experiments are described which test these predictions and whose results could verify or destroy the theory.
Defining software science counting strategies
Authors: Salt Norman F.
Published: November 2005

Although the Software Science metrics originally proposed by Halstead are appealing, calculation of the metrics depends on the existence of well-defined counting strategies. The strategies require precise definitions of operators and operands. It is important that the strategies employed be described in research papers. Furthermore, the presentation of helpful examples of the application of the strategies is recommended. Good descriptions do not imply correct strategies, but they do ensure that the strategies can be understood, tested, and evaluated. Appendices to this paper provide the description of a Pascal counting strategy and an example of applying the strategy.
A separate compilation facility for PASCAL
Authors: Kranc Morris E.
Published: November 2005

A separate compilation facility for Pascal is described. This facility enables the sharing of global data, determines the effects of changes to global data and minimizes recompilation due to global data changes.
A data type theory
Authors: Greiter Gebhard
Published: November 2005

A mathematical model for the notion "data type" is presented. The proposed theory seems to be at least as powerful as the initial algebra approach (see [1]), but can be handled far more easily. A clear distinction is drawn between algebras that are data types and those being merely implementations of types. If an algebra is a type, then each of its elements can be calculated by finite application of operators associated to that type. The model includes error handling.
Structured data flow programming
Authors: de Jong M. D. , Hankin C. L.
Published: November 2005

Although both structured programming (particularly top-down stepwise refinement) [4,7,17] and a data flow view of parallel processing [1,8,11] have been with us now for many years, no attempt has been made to unite the two fields: This paper describes an experiment that unites the two areas in both a textual and a graphical framework. Two packages are described. One produces a Cajole program [13] from input consisting of high-level function definitions together with refinements; and the other produces machine code for a data flow machine from a two dimensional graphical description of a programming problem. An example of each of the systems is given.
A nesting level complexity measure
Authors: Piwowarski Paul
Published: November 2005

Two well-publicized program complexity measures are software science and cyclomatic complexity. Three areas where these measures do not always follow our intuitive notions of complexity are: structured vs unstructured programs, nested vs sequential predicates, and the use of case statements. This paper defines a nesting level complexity measure that punishes unstructuredness, and the nesting of predicates, and rewards the use of case statements. Examples are given where the nesting level complexity agrees with intuitive rankings of program structures where software science, cyclomatic complexity, and their suggested refinements do not.
On data flow guided program testing
Authors: Laski Janusz
Published: November 2005

A structural approach to testing employing properties of data flow in a program is proposed. The basic notion introduced is that of data context of a program block. It represents the set of all tuples of definitions of the block arguments that are simultaneously live when the control reaches the block. Two testing strategies have been proposed: block testing, exercising every block for all its elementary contexts and d-tree testing exercising the definition tree rooted at an elementary context of the stop/exit instruction.
The simplest functional programming language
Authors: Spector David
Published: November 2005

This paper describes a prefix version of Alonzo Church's Lambda Calculus called "$", named for its single operator, "$". The $ language is the simplest form of functional programming, consisting as it does in the iterative application of a simple substitution rule on well-formed strings of the language. The $ language is capable of modeling Boolean algebra and number theory and probably has the computational power of a single-tape Turing machine. It is fun to experiment with, especially interactively on a computer, using an interpreter.
Chatin's graph coloring algorithm as a method for assigning positions to Diana attributes
Authors: Ambler Arol , Trawick Robert
Published: November 2005

Diana, the widely used abstraction for Ada compilers' intermediate representation of Ada programs, consists of graphs of attributed nodes. A graph-coloring algorithm allocates positions for attributes within nodes of the graph, making a space and time-efficient implementation.
Prolog compared with LISP?
Authors: O'Keefe R. A.
Published: November 2005

In the recent ACM Symposium on LISP and Functional Programming, there was a paper with the title "Prolog Compared With LISP" [2] . In it, Gutierrez presents a program in LISP, and a related program in Prolog, and uses the inferior performance of the latter to suggest in strong terms that advocates of Prolog may have over-stated its performance. However, his program makes very poor use of Prolog. In this article, I point out which features of Prolog have been misused and give guidelines for their proper use. I also compare a new Prolog and LISP program performing a similar task, and find that the execution times are comparable. This is in accord with earlier results [4].
A note on deadlock-free proofs of network of processes
Authors: Zedan H.
Published: November 2005

The processes in a network are categorized according to their functionalities at a given stage in the computation. A simple criterion for total correctness of a set of communicating processes is also given along with a necessary and sufficient condition to prove the absence of deadlock.
A graphical abstract programming language
Authors: Albizuri-Romero Miren Begona
Published: November 2005

The current goals of programming are acheived through modularity and abstraction. Structured programs, which embody these two methodologies, have a natural representation through a graphical abstract programming language (GAL) which has been devised for this purpose. GAL represents language structures instead of strings of characters. The Graphical Abstract Language attempts to be closer to languages amenable to structured programming and design. Each template represents a structure and a program is constructed by the union of structures, and each of these is a structure of arbitrary complexity. The process template is the minimum, indivisible unit. As a result of the recursive nesting of structures the final product, i.e. a program, is a hierarchical structure.
Construction of an ELL(1) syntax analyser for Ada with the compiler-generator LILA
Authors: Craeynest Dirk , Vansteenkiste Geert , Lewi Johan
Published: November 2005

LILA (a Language Implementation Laboratory) is a compiler writing system that promotes the modular design and implementation of compilers. The input of LILA is based on an elaborated form of the so-called attribute grammar [KNUT68]. In the LILA input, attribute handling, semantic actions, declarations of objects (constants, types, variables, procedures and functions) and error recovery information are specified local to each syntax rule. The syntax formalism used in the LILA input is an extention of the context-free syntax, called Extended Context - Free (ECF), allowing recursive as well as iterative definitions.For a further description of LILA and the underlying methodology, we refer to "A Programming Methodology in Compiler Construction" [LEWI79] [LEWI82].This article describes part of the results of a dissertation [CRAE82], made at the Katholieke Universiteit Leuven, in order to obtain a universty degree in informatics ('licentiaat informatica').
GRASE
Authors: Albizuri-Romero Miren Begona
Published: November 2005

GRASE proves the advantages of an interactive implementation of an abstract structured language. To meet the need for improved designing, implementation, maintenance, and documentation of structured computer proqrams, a system for interactive and effective communication is presented.GRASE is an interactive graphical syntax-directed editor for development of structured programs. The system is a language-oriented editor in which the programs are created and modified according to the syntax structure of the languaqe, instead of characters and lines, and to the program graphical representation. The program graphical representation is found on an abstract structured language [1] which is a flowcharting technique for structured programs. The author has used these graphs as point of departure for designing a system which develops structured programs only.The result is a system which provides support for the production of Structured software. Design is facilitated through the possibility of working in a structured fashion without a programming language. Implementation incorporates the automatic insertion of most keywords of the language (PASCAL in this case). Documentation showing program structure (procedure and variable scope) as well as algorithms is produced in the form of graphs, as well as the usual indented source listing and identifier cross reference.
On the design of monitors with priority conditions
Authors: Boddy David E.
Published: November 2005

Hoare[1] introduced the monitor as a tool for structuring the design of concurrent systems such as operating systems. He roposed the use of "priority conditions" to facillitate certain types of scheduling. However in his proposal there are no provisions for allowing a "customer" of the monitor to inquire as to the status of a condition. Such inquiries as "What is the highest priority process waiting on condition X?" or "How many processes are waiting on condition X with highest priority?" are not supported in Hoare's design. This paper investigates the implementation of priority conditions for monitors under UCSD Pascal and proposes two such status queries which are both useful and efficient. It is shown that the implementation of Hoare's "alarmclock" monitor is made simpler and more efficient through the use of these queries.
An acceptive grammar for the natural language English
Authors: Feldmann Harry
Published: November 2005

This paper presents an 'Acceptive Grammar' (Feldmann 83a) for a reasonable large subset of the natural language English. The grammar describes all decidable language properties, even context dependences and multiple accepting sequences, and needs no informal augments ! The rules of the Acceptive Grammar are given in form of SIMULA procedures and their graphical representations in form of easy readable SIMULA comments. The complete graphical representations of 'Basics of English' and 'Essentials of English' are listed in sections 3 and 4. The 'actual lexicon' of all entries which occur in the examples of this paper is listed in section 6. The examples are unabridged and show the input, which should be a CLAUSE (section 4) of natural English, and the output, which is a (possibly multiple) parse tree of the CLAUSE or an errordump.
Towers of Hanoi revisited a nonrecursive surprise
Authors: Mayer Herbert , Perkins Don
Published: November 2005

We describe a simple algorithm that solves the inherently recursive towers of Hanoi problem via iteration. To demonstrate the feasibility of the solution an implementation in Fortran with generated run-time output is appended.
Free and bound generics
Authors: Boyd Stowe
Published: November 2005

A description of two fundamentally distinct techniques for the implementation of abstract data types within Modular C, a preprocessor extension of C. Issues of reusability, environmental design, and efficiency are discussed as criteria for the selection of a target form for abstract data types. Automated conversion of one sort of abstract data type to the other is investigated.
In defense of simplicity of comment syntax
Authors: Benepe David B.
Published: November 2005

A recent proposal of comment syntax introduces unnecessary complexity. The purpose of comments is reviewed. A simpler approach is suggested.
Structured decision tables
Authors: McMullen Bill
Published: November 2005

A set of notational conventions and definitions are introduced to supplement traditional decision table documentation. The resulting decision tables can more easily and effectively present the functional structure of the process being documented, can extend the applicability of decision tables to a broader scope of process documentation situations, and can enhance the advantages of the use of decision tables over other documentation techniques.
Practical experiences with automatic repair of syntactical errors or syntactical error repair in the DAS compiler
Authors: van Katwijk J.
Published: November 2005

In this note some practical experiences with error repair methods are discussed. Two methods, a continuation method designed in Karlsruhe and the method used in the Berkeley PASCAL compiler, have been investigated for use in a compiler for an Ada subset, the DAS (Delft Ada Subset) compiler.The method finally applied is the natural synthesis of those two methods.
An exception-based mechanism for syntactic error recovery
Authors: Turba Thomas N.
Published: November 2005

This paper describes a method of syntactic error recovery that is similar, in many respects, to exception handling in Ada® and CLU. The mechanism is based on the static specification of error contexts that inform the parser about possible recovery points that it can use when an error occurs. Selection of a recovery point is based on the present state of the parse (i.e., what contexts are eligible for selection) and the symbols in the input stream.
OOPAL
Authors: Mougin Philippe , Ducasse Stéphane
Published: November 2005

Array programming shines in its ability to express computations at a high-level of abstraction, allowing one to manipulate and query whole
sets
of data at
once
. This paper presents the OPA model that enhances object-oriented programming with array programming features. The goal of OPA is to determine a minimum set of modifications that must be made to the traditional object model in order to take advantage of the possibilities of array programming. It is based on a minimal extension of method invocation and the definition of a kernel of methods implementing fundamental array programming operations. The OPA model presents a generalization of traditional message passing in the sense that a message can be send to an entire set of objects. The model is validated in FS, a new scripting language.
An on-the-fly mark and sweep garbage collector based on sliding views
Authors: Azatchi Hezi , Levanoni Yossi , Paz Harel , Petrank Erez
Published: November 2005

With concurrent and garbage collected languages like Java and C# becoming popular, the need for a suitable non-intrusive, efficient, and concurrent multiprocessor garbage collector has become acute. We propose a novel mark and sweep on-the-fly algorithm based on the sliding views mechanism of Levanoni and Petrank. We have implemented our collector on the Jikes Java Virtual Machine running on a Netfinity multiprocessor and compared it to the concurrent algorithm and to the stop-the-world collector supplied with Jikes JVM. The maximum pause time that we measured with our benchmarks over all runs was 2ms. In all runs, the pause times were smaller than those of the stop-the-world collector by two orders of magnitude and they were also always shorter than the pauses of the Jikes concurrent collector. Throughput measurements of the new garbage collector show that it outperforms the Jikes concurrent collector by up to 60%. As expected, the stop-the-world does better than the on-the-fly collectors with results showing about 10% difference.On top of being an effective mark and sweep on-the-fly collector standing on its own, our collector may also be used as a backup collector (collecting cyclic data structures) for the Levanoni-Petrank reference counting collector. These two algorithms perfectly fit sharing the same allocator, a similar data structure, and a similar JVM interface.
Information retrieval and the query language
Authors: Waksman Abraham
Published: November 2005

This paper addresses itself to the information retrieval problem of a manager within an organization. We feel that the approach taken in specifying such a system is sufficiently general to be suitable for application to other system specifications. It is assumed that the manager wishes to interrogate a system containing a data base that relates to his task of making decisions in the course of running his part of an organization.To meet the manager's needs we have attempted to define the models a manager uses in making decisions. We have further made an approach toward problem definition for the manager.To interpret a manager's queries stemming from encountered or anticipated problems, we have attempted to define an inferential system. The inferential system has a further task of specifying the retrieval of information that might exist only in an implicit form. Finally, we demonstrate an approach toward the design of a query language for the manager, which could become "natural" to him after short experience.
FOL
Authors: Claybrook Billy G.
Published: November 2005

FOL is a language for implementing file organizations. It is implemented in LPL, a list processing language that is an extension of PL/1. FOL presents the user with a convenient means for declaring the structure of records in a file. Either tree structured or graph structured files can be created and manipulated. The language treats records in a file as nodes in a list. The paper describes other file manipulation languages like APL and IDS. The data organization of FOL and the procedural language for declaring record structures and data manipulation commands are given.
Dynamic storage routines for Fortran programs
Authors: Bray David W.
Published: November 2005

This paper describes a set of list processing routines which augment the capabilities of FORTRAN by providing the programmer with the ability to dynamically allocate arbitrarily complicated data structures. The basic structure provided is a two dimensional array.
Detab/65 in third-generation Cobol
Authors: Silberg Bruce
Published: November 2005

Detab/65, which was distributed by the ACM, is a decision table preprocessor written in second-generation Cobol (Cobol-61). This paper indicates the history of decision tables, reviews their structure, advantages and disadvantages, and presents the modifications to Detab/65 that are needed to allow its compilation by Cobol-65 or ANS Cobol.
Tabsol decision table preprocessor
Authors: Sterbenz Robert F.
Published: November 2005

This paper describes the Tabsol Decision Table Preprocessor, a program product of the B.F. Goodrich Company. The Tabsol (Tabular systems oriented language) Preprocessor, itself written in ANSI Cobol, is designed to translate horizontalrule, extended-entry decision tables into equivalent Cobol statements. Design objectives, language format and implementation results of the Tabsol Preprocessor are summarized in this paper. This preprocessor has been in full production use by the Information Systems Department of B.F. Goodrich Chemical Company since January 1971.
An automatic decision-logic-table processor
Authors: Lemoine Donald J.
Published: November 2005

The value of decision-logic-tables as a tool for computer programming has been brought forth by the development of several programming languages. The well-known decision-logic-table programming languages are designed as input to translators. Instead of converting the input decision-logic tables to an executable form, these translators convert the source program to some other well-known language, such as Fortran. The appropriate compiler then converts the resulting source-language program to an executable form.The DEcision Logic TAble programming language, Delta, described here, is an automatic decision table processor, eliminating the need to translate the input into some intermediate source language. Basic features of decision-logic tables are used as a foundation for Delta. The syntax of Delta is similar to that of PL/I. Although Delta is limited in scope, it is expandable. Derived from the Purdue University Fast Fortran Translator, Pufft, the Delta processor performs both a syntax analysis and generates code, in one pass. The code generated is not machine language, but is an internal representation of the object language program.
Static profile and dynamic behavior of COBOL programs
Authors: Chevance R. J. , Heidet T.
Published: November 2005

A measurement system for gathering a static profile and dynamic characteristics of COBOL programs at the source language level is described. Static and dynamic results are presented and discussed.
The Advanced Interactive Debugging System (AIDS)
Authors: Hart Jolene J.
Published: November 2005

The Advanced Interactive Debugging System (AIDS) is described. It is a powerful high-level symbolic interactive debugging aid. AIDS is intended to be available in a program's environment without requiring debugging statements in the program's source code or inclusion of AIDS in the program's executable module.
A short note on scanning signed integers
Authors: Low James R.
Published: November 2005

The "common sense" algorithm for translating from signed decimal representation to the two's complement binary representation doesn't always work. A correct algorithm (reinvented or discovered many times by various people) is presented. The presentation will hopefully encourage use of the correct algorithm and discourage use of the "common sense" algorithm.
Traversable stack with fewer errors
Authors: Veloso Paulo A. S.
Published: November 2005

A complete finite "algebraic" specification for a version of traversable stack with fewer error conditions is presented. This is used to illustrate some issues concerning formal specification of data types, namely naturalness and clarity. Uncontrolled errors are considered harmful and canonical-term specifications are considered helpful.
A hierarchical approach to program testing
Authors: Laski Janusz W.
Published: November 2005

A real-environment interactive testing procedure is presented which is based upon a hierarchical decomposition of a program into levels of abstraction. Such a decomposition is defined in terms of a program model which involves both control and data flow. The testing strategy adopted is supposed to follow a typical progress of a programmer who carries out a series of experiments with his program. Several semantical and structural issues involved are discussed.
Assertions in programming languages
Authors: Taylor Richard N.
Published: November 2005

The notion of embedding assertions in applications programs to aid in program verification and testing is not at all new; yet programming language designers seem loath to provide them, at least in useful ways. The Department of Defense language Ada is a case in point. The use of assertions is briefly reviewed, suggestions for their incorporation in languages is given, and an example of how they have been provided for the language HAL/S is shown.
An experimental LISP system for the SPERRY UNIVAC 1100 Series
Authors: Firestone Roger M.
Published: November 2005

An experimental LISP system has been developed for use on SPERRY UNIVAC 1100 Series computers. Although the general design of the system is fairly traditional, a number of extensions have been made to the customary nucleus which significantly improve the ease of use of the language. These extensions include external environment modifications as well as new internal functions. Some concepts have also been borrowed from other programming languages, as well. Because 1100 Series LISP does not contain a compiler, considerable attention has been given to the efficient use of computing resources, and some of the extensions are designed with more efficient utilization as the primary objective. Finally, some of the extensions were compelled to exist by the inherent logical structure of the LISP language, and their introduction into other LISP systems can be recommended.
Can Ada replace FORTRAN for numerical computation?
Authors: Morris Alfred H.
Published: November 2005

In July 1980, the proposed final form of the Ada programming language was released by the U.S. Department of Defense [1]. Even though Ada was not designed specifically for general numeric scientific computation, nevertheless the question arises to whether it is appropriate for this purpose. This question can best be answered by consideration of the following question: Is Ada a suitable replacement for the programming language FORTRAN? This paper discusses those constructs of Ada which are pertinent to the matter and are considered defective. It is noted that the array defects are exceptionally critical, not providing needed capabilities that exist in FORTRAN and have been extensively used for a quarter century.
Euclid and Modula
Authors: Barnard David T. , Elliott W. David , Thompson David H.
Published: November 2005

Both Euclid and Modula are programming languages based on Pascal and intended for writing system software such as operating system kernels. The further goals of each language, however, resulted in two rather different languages. Modula is meant to be used in multiprogramming systems primarily on mini-computers; thus Modula aims for very small run-time support and efficient compilation by a small compiler. Many of the Euclid language design decisions, on the other hand, were influenced by the authors' overriding concern for the ability to verify Euclid programs. This paper discusses design goals of the two languages and the language differences that resulted. After contrasting individual features of the two languages, modules and multiprogramming are discussed in more detail.
On the use of the cyclomatic number to measure program complexity
Authors: Elshoff James L. , Marcotty Michael
Published: November 2005

The October 1977 issue of SIGPLAN Notices carries an article that compares functionally equivalent programs that differ in their internal structure. The basis for comparing the programs is a measure called cyclomatic complexity whose value is the cyclomatic number of the graph that corresponds to the flow of control of the program. One program is of particular interest since all of the well-structured versions of the program that are discussed have a higher cyclomatic complexity than the unstructured version. In this paper another well-structured version of the program is presented for which the cyclomatic complexity is reduced to that of the original unstructured version. In the process, some of the shortcomings of the cyclomatic number as a complexity measure are revealed.
Abstract specification of resource accessing disciplines
Authors: Lauer P. E. , Shields M. W.
Published: November 2005

A macro notation incorporating path notation is introduced. The notation was designed to permit the specification of the behaviour of a distributed system in terms of resources characterized by associated synchronization statements. The proper co-ordination of processes using the resources can thus be stated as the permissible order of execution of operations on shared resources as part of the resource definition. This contrasts with the usual "process oriented" approach which associates synchronization statements with the processes using the resource. This makes proper co-ordination of processes part of the individual task of each process. We argue that the process oriented approach is not suited for specifying highly parallel systems with distributed decision capabilities. The notions of adequacy, starvation, priority and interrupts are discussed in the context of our "resource oriented" approach and compared with thei counterparts in a "process oriented" approach. Semi formal demonstrations of the adequacy of simple but realistic example systems are sketched.
Scope conserving expression evaluation
Authors: Chroust G.
Published: November 2005

One important aspect of the object code generated for arithmetic expressions in higher level languages is the amount of temporary storage needed during evaluation. This amount is a function of the sequence in which an expression's subexpression are evaluated. Usually the implementor has the freedom to choose any order of evaluation, provided that operations are executed after the evaluation of their respective operands. This allows for the use of a multitude of possible evaluation sequences. In 1971 the author identified a large class of such evaluation strategies by the newly coined term 'scope conserving'.In this paper we show that this class of strategies will minimize the amount of temporary storage with respect to a very general cost function. The optimizing sequencing strategies for temporary storage derived by Anderson, Colin, Nakata, Redziejowski, Sethi-Ullmann and Chroust are shown to be expressible in the model.
An extension to the cyclomatic measure of program complexity
Authors: Myers Glenford J.
Published: November 2005

A recent paper has described a graph-theoretic measure of program complexity, where a program's complexity is assumed to be only a factor of the program's decision structure. However several anomalies have been found where a higher complexity measure would be calculated for a program of lesser complexity than for a more-complex program. This paper discusses these anomalies, describes a simple extension to the measure to eliminate them, and applies the measure to several programs in the literature.
The non-desirability of structured programming in user languages
Authors: Atkinson George
Published: November 2005

The applicability of structured programming concepts in the design of special-purpose languages for the nonprogramming "casual user" is examined. Design criteria for a casual user language are presented along with a modus operendi (the 4:50 FRIDAY approach) for developing "natural notations" which are easily learned and used. An example of a casual user language is presented along with evidence that, for the casual user, the ability to write or even recognize a well-structured program is an unnecessary burden.
Fortran
Authors: Woolley John D.
Published: November 2005

This document is intended to rapidly acquaint the reader with the changes that have occurred in the Fortran language in the past decade. It assumes some familiarity with the Fortran currently in use.
Some remarks on abstract data types
Authors: Levy Michael R.
Published: November 2005

Some attention has been given recently to abstract data types as a powerful programming concept [1,2,3,4]. In this approach, abstract data types are viewed as sets together with the operators on these sets. One may define a data type either operationally, by writing the procedures for each operator, or denotationally, using many-sorted (heterogeneous) algebras as described for example by Guttag [1,2]. In the algebraic approach to specifying abstract data types, these two problems are raised.1) It is difficult to prove "sufficiency-completeness". That is, it is difficult to prove that the equations characterize the data structure in question.2) The algebraic presentation (that is, the set of equations defining the type) is not very readable or easy to construct.The purpose of this note is to point out that both these problems have a solution, and in fact the solutions are interrelated. These results were originally developed by Goguen
et al
[5], and an intuitive description of the process is given here.
The automatic measurement of the relative merits of student programs
Authors: Robinson S. K. , Torsun I. S.
Published: November 2005

Elementary course work assessments at Brunel University consist of programming problems with guidelines as to the method of solution. With such an environment and a given language (Fortran) this paper provides a method whereby the set of submitted solutions are automatically assessed by their relative merits to the solution produced by the lecturer concerned.
A translation machine with automated top-down parsing
Authors: Lawson Harold W. , Doucette David R.
Published: November 2005

The top-down method of parsing programming languages has been widely used in commercially available compilers. Suprisingly, techniques for automating syntax-directed, top-down parsing have not been widely available. This paper describes a practical top-down parsing method which is a part of a general purpose translation machine automaton. The syntactical description capabilities provide for the convenient and efficient specification of linguistic constructs which are difficult or lengthy to specify in BNF metalanguage. The translation machine, which provides for semantic as well as syntactic operations, has been designed for implementation in hardware, microcode, or software. The translation machine can be utilized for convenient and efficient construction of a wide variety of programs that perform source string to object string transformations.
Some user-defined control functions for more readable APL programs
Authors: Mason James A.
Published: November 2005

Some improved control statements for APL are presented, which the user can define and use without requiring either preprocessing or modification of the interpreter. A preprocessor is also given, however, in case improved execution time of programs using the control statements is desired.
Mask and format
Authors: Ditzel D. R. , Hutchison P. C.
Published: November 2005

String-processing and editing operators have been notably absent from most high-level general-purpose programming languages. With the exception of the "substring" function, all formating of character strings and numbers has been done via I/O statements. In order to use the editing capabilities of these statements internally, language designers have resorted to such awkard techniques as "core to core I/O" in Fortran, or PUT STRING in PL/I. Two operators currently used with the SYMBOL-2R computer system eliminate this difficulty and provide an excellent method of editing and formatting both numbers and character strings.
Structure charts a structured alternative to flowcharts
Authors: Lindsey C. H.
Published: November 2005

Conventional flowcharts are a hindrance to structured programming. An alternative notation, which emphasises the nested structure of programs, is proposed. The notation allows for only those goto s which are safe in a structured program. Unbelievers in Structured Programming are advised not to read this paper.
An object-oriented architecture for intelligent tutoring systems
Authors: Bonar Jeffrey , Cunningham Robert , Schultz Jamie
Published: November 2005

We describe an object-oriented architecture for intelligent tutoring systems. The architecture is oriented around objects that represent the various knowledge elements that are to be taught by the tutor. Each of these knowledge elements, called
bites
, inherits both a knowledge organization describing the kind of knowledge represented and tutoring components that provide the functionality to accomplish standard tutoring tasks like diagnosis, student modeling, and task selection. We illustrate the approach with several tutors implemented in our lab.
Type-checking Smalltalk
Authors: Johnson Ralph E.
Published: November 2005

Although most attempts to speed-up Smalltalk have focused on providing more efficient interpreters, code optimization is probably necessary for further increases in speed. A type-system for Smalltalk is a prerequisite for building an optimizing compiler. Unfortunately, none of the type-systems so far proposed for Smalltalk are adequate; they either cause nearly all Smalltalk programs to be type incorrect, allow run-time type errors, or do not provide enough information for optimization. This paper presents a type-system for Smalltalk that is suitable for code optimization.