bluuebunny/crossref_metadata_2025 huggingface dataset:
"Handling large, complex and variable job-control streams using a procedure invocation package ('PIP') and a pseudo-library"
Authors: Tutleman Jonathan S.
Published: November 2005

A. A 'Procedure Invocation Package' ('PIP')
1.2
is system-supplied software which enables execution of job sequences in addition to those in the user-supplied control stream. These additional sequences may be "canned" or generated within the same computer job. Therefore, it will be of great value in the following instances:1. The control-sequence is large.
1.1
2. The control-sequence is case-dependent (i.e., variable) and even more so when:3. The (eventual) users are not systems-oriented and would have problems in correctly modifying the control stream.4. The user-level control stream is actually on cards and users would experience difficulty in resequencing a (accidentally) missequenced deck.
1.6
Also, by reducing the key-punching effort, errors are reduced.
1.5
B. The 'PIP' concept can also be used in the manipulation of the many files as a set, namely in "backup" where the files are copied from disk to tape; "purge" where the files are removed from disk and "retrieve" where the files are reinstalled.
1.7
To organize the files a list (or "pseudo library") is created
2.2, 2.3
.C. A further use of the 'PIP' is in program-file
2.1
development/ reinstallation, obviating a separate control deck for each file, with benefits in reduced card-consumption, punching-time and errors.The order and scope of the tasks is shown in Table A. Further, the technique reduces all user decks to a basic, minimum format as shown in Table B.
A Fortran preprocessor for the large program environment
Authors: Wagner Neal R.
Published: November 2005

The use of a preprocessor to aid structured programming in Fortran has been widely discussed. This article considers a design philosophy which is especially oriented toward large program development and maintenance. The design is distinguished by the retention of the form of the original source program in the standard Fortran output by the preprocessor. A specific implementation is described.
A poor man's realization of recursive structured Fortran
Authors: Sassa Masataka
Published: November 2005

A simple method for converting Recursive Structured Fortran programs into Fortran programs is presented. By using a simple assembly-coded routine and getting slightly beyond standard Fortran such as using ENTRY statements, the method realizes recursive procedures and functions with "call by reference" parameters, which were not possible in previous methods. It imposes only few restrictions on users. Relevant implementation problems and solutions are discussed. By utilizing a macro processor, the converter was easily made. It deals with recursion simultaneously with "structuring" of Fortran.
An extension to the language-based access-control mechanism of Jones and Liskov
Authors: Stepoway Stephen L. , Silberschatz Abraham
Published: November 2005

The language-based access-control mechanism of Jones and Liskov makes possible the controlled sharing of information in a programming language in a natural way. Unfortunately, many semantically correct programs cannot be written due to a deficiency in the binding rule. This paper proposes an extension to this mechanism which removes some unnecessary restrictions on the writing of access-correct programs.
Users' experience with the ILLIAC IV system and its programming languages
Authors: Perrott R. H. , Stevenson D. K.
Published: November 2005

The ILLIAC IV is a unique machine which has led the research and development of lockstep parallel processing. The machine has been operational since 1973, in experimental mode, and since 1975 in full production mode. There has been on the order of a hundred users of the machine and these users and their codes have been well documented. Four languages are available on the machine ranging from high level to machine code. A survey has been conducted of the users in order to determine how the ILLIAC IV has been employed and how the high level programming languages have facilitated the use of this machine. This paper presents the results of that survey.The survey attempts to confirm or eliminate some of the folklore that has grown up around the ILLIAC IV facility. It can be helpful in the design of the next generation of supercomputers and their languages and in the improvement of the present generation of languages. The responses to the survey indicate: 1) that the ILLIAC IV has been accepted by the scientific community; 2) that a wide range of different application areas have used the machine; 3) that users have had to construct their programs so as to minimise the effects of the serious bottleneck created by the movement of data between the main and backing stores; and 4) that the high level programming languages available have insufficient or inefficient structures which at times require the use of machine code.
Naming subprograms with clarity
Authors: Booch Grady
Published: November 2005

This paper presents a language construct for subprogram specification. This construct offers increased clarity with an insignificant overhead in compilation time.
A Pascal compiler testing facility
Authors: Dixon Douglas F.
Published: November 2005

The simplicity and intelligent design of the Pascal language has allowed us to develop an in-house compiler testing facility to validate the quality of Pascal compilers for use on production systems. Our facility includes several packages of compiler test programs, and also provides tools and techniques for automating the execution of these tests. By combining the different testing strategies of these compiler validation packages, the testing facility provides graduated levels of confidence in a Pascal compiler. The facility has been primarily used to validate successive releases of an extended Pascal compiler.
Pascal for operating software?
Authors: Prael C. E.
Published: November 2005

The general status of PASCAL in the commercial field is described. Various characteristics of the language are examined critically in the context of operating software and utility program implementations.
Seven sorts of programs
Authors: Scowen R. S. , Ciechanowicz Z. J.
Published: November 2005

When computer scientists talk of debugging programs they mean detecting and removing the errors. This naturally encourages an over-simple view that a program is either right or wrong. This note suggests that there are at least seven degrees of correctness for a program. A simple Algol 60 program that calculates the average of up to ten numbers is used as an example.This note originally appeared as an appendix to a report on Compiler Validation published by NPL [SCOW80].
A short introduction to Concurrent Euclid
Authors: Holt R. C.
Published: November 2005

This is an introduction to Concurrent Euclid (CE), a language designed for high performance, highly reliable system software, such as operating systems, compilers and embedded microprocessor systems. CE is a Pascal-based language with processes and monitors (as specified by C. A. R. Hoare). It has language constructs needed for systems programming including separate compilation, variables at absolute addresses, type converters, long integers and so on.A Small (50k bytes), fast, portable compiler is available for CE running under UNIX. It is self-compiling and has replaceable code generators. There exist high quality code generators for several computers including the PDP-11, VAX, Motorola 68000 and Motorola 6809. These typically generate as good or better code than other compilers such as "C".CE programs that use concurrency can be run on a bare machine (supported by a small assembly language kernel), or in simulated mode as an ordinary appearing job running under an operating system.CE is defined precisely by "Specification of Concurrent Euclid" by Cordy and Holt.
Indirect Threaded Code used to emulate a virtual machine
Authors: Thanh Nguyen T. , Raschner E. Walter
Published: November 2005

Threaded Code and Indirect Threaded Code are used to structure assembler programs, Threaded Code is also used to realise virtual machines (e.g. Pascal p-machine).This paper presents the realization of a virtual machine with Indirect Threaded Code and decribes the advantages and disadvantages of Indirect Thread Code with a Pascal compiler that was changed to generate Indirect Threaded Code.
Towards a novel string processing language
Authors: McCaig Martin
Published: November 2005

This paper describes the operation of a text scanner in terms of a novel sort of finite state machine. Eventually this scanner will be incorporated into a string processing language designed for applications in which pattern recognition can be accomplished by a simple left to right scan.
Functional programming and the two-pass assembler
Authors: Early Grady
Published: November 2005

The classical two-pass assembly process is adapted for implementation in a functional programming language similar to Backus' FP language. We show that the parallelism inherent in FP languages allows radical changes in the design of such well-known algorithms as the two-pass assembler.
An improvement over deeply nested IF-THEN-ELSE control structures
Authors: Hill Gregory P.
Published: November 2005

This paper describes an alternative to deeply nested IF-THEN-ELSE control structures within high-level language programs. This alternative improves the maintainability and extensibility of programming technique uses a CASE or SELECT control structure nested within an iterative DO structure that causes all previously nested IF-THEN-ELSE control structures to become equal in level to the second nested IF. This technique promotes quicker success by programmers other than the author when they make later modifications to the programs because of the reduction in program complexity.
An advanced programming language definition and domain correctness of programs
Authors: Culik Karel
Published: November 2005

Program execution is not adequately reflected in usual syntactic programming language definition by formal grammar, although either actual or mental execution is referred to during reading (tracing) and correctness proving. An advanced programming languages definition associates in input/output variables, the domain, and the computable function with each program. It is based on a computer automaton when inputs from In, states from St are viewed as instructions, memory states, respectively. The heart of it, is its transition (next-state) function trans: In x St → St.Arithmetic symbols occuring in a program are interpreted (by programmer) in usual infinite arithmetics during problem solving while they are interpreted (by a computer) in finite computer arithmetics when the program is executed. The program is characterized by its execution-semantics expressed in its control (next-instruction) function contr: In x St → In. The discrepancy between finite and infinite interpretation-semantics are studied as suggested in [Hoar 69], in particular, the two computable functions are compared.Total and partial correctness [Mann 74] does not show which interpretation should be considered; therefore, the third component of a proof of correctness, a domain correctness proof, is added.
A comparison of LISP specifications of function definition and argument handling
Authors: Jones Mark A.
Published: November 2005

This paper presents the differences in several LISP definitions regarding the interpretation of various function types (EXPR, FEXPR, LEXPR, NEXPR). The definitions are compared according to their syntactic conventions for specifying the function type and method of argument handling--whether arguments are evaluated or unevaluated and whether their number is fixed or variable. A summary figure is given in the Appendix.
A letter oriented minimal perfect hashing function
Authors: Cook Curtis R. , Oldehoeft R. R.
Published: November 2005

Cichelli has presented a simple method for constructing minimal perfect hash tables of identifiers for small static word sets. The hash function value for a word is computed as the sum of the length of the word and the values associated with the first and last letters of the word. Cichelli's backtracking algorithm considers one word at a time and performs an exhaustive search to find the letter value assignments. In considering heuristics to improve his algorithm we were led to develop a letter oriented algorithm that handles more than one word per iteration and that frequently outperforms Cichelli's. We also investigate the impact of relaxing the minimality requirement and allowing blank spaces in the constructed table. This substantially reduced the execution time of the algorithm. This relaxation and partitioning data sets are shown to be two useful schemes for handling large data sets.
The object oriented pre-compiler
Authors: Cox Brad L.
Published: November 2005

This describes the Object Oriented Pre-Compiler,
OOPC
, a language and a run-time library for producing C programs that operate by the run-time conventions of Smalltalk 80
2
in a UNIX
3
environment. These languages offer Object Oriented Programming in which data, and the programs which may access it, are designed, built and maintained as inseparable units called
objects
.The precompiler is backed by a library which supports Smalltalk 80's interpretation of messaging; binding of a message to its target routine is done at run time. The library also contains a growing number of primitive class definitions, such as an
Object
class whose capabilities are inherited by every object in the system. The library provides many, but not all, capabilities of Smalltalk. An added capability is
object save/restore
, which allows any object to convert itself and all sub-objects into linear form for storage on disk. Important missing features are automatic memory management and Smalltalk's impressive collection of classes to support a graphical human interface.
A string extension for Pascal
Authors: Boswell F. D. , Carmody M. J. , Grove T. R.
Published: November 2005

The Pascal language, as described by the ISO Draft Proposal or Jensen and Wirth, is deficient in its facilities for character-string manipulation. A proposal for an extension to Pascal which facilitates the manipulation of character strings is given. The extension consists of a modification to the "type compatibility" rules of the language, plus a set of pre-defined functions and procedures. The extension has been implemented in the Waterloo Pascal compiler and the Waterloo microPascal interpreter.
Context sensitive formatting
Authors: Jackel Manfred
Published: November 2005

Formatting is one method of making program texts more readable. It has been heavily discussed in this NOTICES and a lot of proposals how to do it best have been made, especially with regard to PASCAL. So far, formatting means to present certain syntactical constructs of a program text in a suitable layout shape, which is achieved mainly by indentation and spreading the constructs over several lines. So the context free syntax is visualized by prettyprinting. As far as formatting is constrained to this, we call it context free formatting here.
DUIF
Authors: Van Oost E. M. J. C.
Published: November 2005

A new graphical program representation is proposed.This notation, called "Dynamic User interface Flowchart" (DUIF), provides a clear perceptual view of the underlying processes, revealing relevant information at different levels of abstraction. A DUIF is a tree structured diagram combined with source code statements and data declarations.Used as design tool, it forces the designer to produce structured code through stepwise refinement of data objects.A DUIF picture allows to capture the dynamic properties of an executing program by visualization of data and control flow within program segments.This paper introduces the diagramming conventions of the DUIF notation and the underlying methodology.
Discussion of statement labels
Authors: Pentzlin Karl L.
Published: November 2005

The author argues that statement labels should only be used to name statements for documentation purposes. For other applications that are common now, like definitions of GOTO destinations and test point declarations, language definitions should provide other constructs.Especially, a TRANSFER/JUNCTION construct is proposed that - although semantically equivalent - is considered to be something less harmful than the GOTO construct.
acce-specifications
Authors: Greiter Gebh.
Published: November 2005

This paper describes a method for building data type specifications that can be proved to be complete and consistent. More, they are abstract and also executable.The method ist based on the type theory developed in [1].
Structured transfer of control
Authors: Williams David O.
Published: November 2005

A proposal is presented for the generalisation of certain control structures by permitting the (optional) execution of a block of code:(i) at each new cycle in a loop(ii) following termination of a loop(iii)following termination of the "normal" code of a subprogram/procedure.
Alternate returns
Authors: Williams David O.
Published: November 2005

It is suggested that facilities for the direct transfer of control upon return from a called subprogram/procedure, similar to (but preferably improving upon) the Alternate RETURN in FORTRAN-77, provide an important tool for the software designer.
A new programming language
Authors: Anselmi L.
Published: November 2005

GALILEI is multipurpose, high level programming language. Its basic feature is its extreme simplicity. GALILEI has the following principal characteristics:a) there exists only one type of procedure;b) the order of execution is controlled by means of the unique statement DEC and two special labels -> and =>;c) there is only one repetitive statement: REPEAT;d) the variable attributes are defined through their initial values and consequently the use of keywords is eliminated.For GALILEI there does not yet exist a compiler, thus in this paper only the principal characteristics of the language are described.
A portable pseudo-code for Pascal-like languages
Authors: Taylor David
Published: November 2005

As an alternative to compilers generating machine code or assembly language, a more portable alternative is to generate a pseudo machine language that can then be transported to various machines and converted to their native code. Herein I shall present a simple mnemonic Pseudo-Code language, and present a few examples of Pascal to Pseudo-Code.
The programming language MINO and its formal definition
Authors: Cooke D. J. , Al-Noufaly M. H. J.
Published: November 2005

MINO (pronounced 'minnow' or 'min-zero') is a block-structured language constructed directly on the formal, mathematical, definition of recursive functions and should therefore be capable of specifying
any
computable mapping. Moreover the denotational description allows MINO to be used as a base on which a progression of other, related and more 'realistic', languages can be bootstrapped. Mathematical properties of such languages can then be linked to the already existing body of knowledge concerning recursive functions.
What is programming really all about?
Authors: Bulman Edward
Published: November 2005

"All generalizations (with the possible exception of this one) are false". (Anon.)
Run-time declaration elaboration
Authors: Faust Don
Published: November 2005

An enhancement of the dynamics of declaration elaboration is suggested and exemplified. It is seen as part of a continuing process in language design, namely, refinement of a language's facility in regard to definition and control of data structures. The objective of this note is to encourage further examination and discussion of this process.
Some remarks on records with variants
Authors: Hoyer Wolfgang
Published: November 2005

In programming practice it is often necessary to subsume records of different types under one common type such as an array, a file or a linked list. One has only to think of differently formatted records in a personnel file or of entries in a compiler's symbol table. Ever since PASCAL, records with variants constitute the most suitable language constructs available for this purpose.The problem of accessing record components within variants has not been satisfactorily solved by today's languages in two respects. In the first place uniqueness is demanded for the component names across all record variants, and this leads to an unnatural denotation in many cases. Secondly, there is no guarantee at compile time that access to a record variant will not result in a runtime error.In the present paper, ways of avoiding these problems are proposed.
Loslan implementation of the AMPL message-passing system
Authors: Milewski Jaroslaw
Published: November 2005

AMPL is an asynchronous message-passing scheme developed at CMU, and Loslan is a universal, Simula-based programming language worked out at the Warsaw University. The paper presents a straightforward implementation of AMPL in Loslan, profiting from the generalized prefixing mechanism of the latter. The method of controlling the communicating processes by handling the so-called awaited condition trees is applicable to other asynchronous message-passing systems.
Another nonrecursive algorithm for the towers of Hanoi
Authors: Stadel Manfred
Published: November 2005

A nonrecursive algorithm for solving the Towers of Hanoi problem is described. The advantage of this algorithm is that it can be easily used by a human to play the game.
An extension proposal for Pascal
Authors: Pentzlin Karl Ludwig
Published: November 2005

The update of a variable (i.e. the assignment of a value which depends on the previous value of that variable) requires that the variable has to be specified in the left-hand part of an assignment statement as well as in the right-hand part again. Therefore, writing of such statements is unnecessarily tedious and error-prone.The proposed solution is to introduce a "pronoun character", which may be used in the right-hand part of an assignment statement, and which then denotes the value which was assigned to the designator just before the assignment statement is executed.
On evolution of FORTRAN
Authors: Van Tuyl Robert R.
Published: November 2005

The GTE Government Systems Corporation, Western Division is engaged in real time and other application software development. Clearly we need the best available tools with which to do the job consistent with our customer contraints. For a variety of reasons, I believe that FORTRAN will remain an important programming tool. The most important of these reasons may be that it has adapted slowly to the changing needs of the software development community.The purpose of this paper is to describe four things which should be done to FORTRAN in the near term. First, we should not add additional control statements. Second, we should add a data structure feature. Third, a referential facility should be added to the language. Fourth, we should add a few simple things that can hide information in one part of a program from another part.
Refactoring for generalization using type constraints
Authors: Tip Frank , Kiezun Adam , Bäumer Dirk
Published: November 2005

Refactoring is the process of applying behavior-preserving transformations (called "refactorings") in order to improve a program's design. Associated with a refactoring is a set of preconditions that must be satisfied to guarantee that program behavior is preserved, and a set of source code modifications. An important category of refactorings is concerned with generalization (e.g.,
Extract Interface
for re-routing the access to a class via a newly created interface, and
Pull Up Members
for moving members into a superclass). For these refactorings, both the preconditions and the set of allowable source code modifications depend on interprocedural relationships between types of variables. We present an approach in which
type constraints
are used to verify the preconditions and to determine the allowable source code modifications for a number of generalization-related refactorings. This work is implemented in the standard distribution of Eclipse (see www.eclipse.org).
A comparative study of language support for generic programming
Authors: Garcia Ronald , Jarvi Jaakko , Lumsdaine Andrew , Siek Jeremy G. , Willcock Jeremiah
Published: November 2005

Many modern programming languages support basic generic programming, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support to a broader, more powerful interpretation of generic programming, and their extensions have proven valuable in practice. This paper reports on a comprehensive comparison of generics in six programming languages: C++, Standard ML, Haskell, Eiffel, Java (with its proposed generics extension), and Generic C. By implementing a substantial example in each of these languages, we identify eight language features that support this broader view of generic programming. We find these features are necessary to avoid awkward designs, poor maintainability, unnecessary run-time checks, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to provide powerful generics and that their absence causes serious difficulties for programmers.
How java programs interact with virtual machines at the microarchitectural level
Authors: Eeckhout Lieven , Georges Andy , De Bosschere Koen
Published: November 2005

Java workloads are becoming increasingly prominent on various platforms ranging from embedded systems, over general-purpose computers to high-end servers. Understanding the implications of all the aspects involved when running Java workloads, is thus extremely important during the design of a system that will run such workloads. In other words, understanding the interaction between the Java application, its input and the virtual machine it runs on, is key to a succesful design. The goal of this paper is to study this complex interaction at the microarchitectural level, e.g., by analyzing the branch behavior, the cache behavior, etc. This is done by measuring a large number of performance characteristics using performance counters on an AMD K7 Duron microprocessor. These performance characteristics are measured for seven virtual machine configurations, and a collection of Java benchmarks with corresponding inputs coming from the SPECjvm98 benchmark suite, the SPECjbb2000 benchmark suite, the Java Grande Forum benchmark suite and an open-source raytracer, called Raja with 19 scene descriptions. This large amount of data is further analyzed using statistical data analysis techniques, namely principal components analysis and cluster analysis. These techniques provide useful insights in an understandable way.From our experiments, we conclude that (i) the behavior observed at the microarchitectural level is primarily determined by the virtual machine for small input sets, e.g., the SPECjvm98 s1 input set; (ii) the behavior can be quite different for various input sets, e.g., short-running versus long-running benchmarks; (iii) for long-running benchmarks with few hot spots, the behavior can be primarily determined by the Java program and not the virtual machine, i.e., all the virtual machines optimize the hot spots to similarly behaving native code; (iv) in general, the behavior of a Java application running on one virtual machine can be significantly different from running on another virtual machine. These conclusions warn researchers working on Java workloads to be careful when using a limited number of Java benchmarks or virtual machines since this might lead to biased conclusions.
Relaxed MultiJava
Authors: Millstein Todd , Reay Mark , Chambers Craig
Published: November 2005

We present the rationale, design, and implementation of Relaxed MultiJava (RMJ), a backward-compatible extension of Java that allows programmers to add new methods to existing classes and to write multimethods. Previous languages supporting these forms of extensibility either restrict their usage to a limited set of programming idioms that can be modularly typechecked (and modularly compiled) or simply forego modular typechecking altogether. In contrast, RMJ supports the new language features in a virtually unrestricted form while still providing mostly-modular static typechecking and fully-modular compilation. In some cases, the RMJ compiler will warn that the potential for a type error exists, but it will still complete compilation. In those cases, a custom class loader transparently performs load-time checking to verify that the potential error is never realized. RMJ's compiler and custom loader cooperate to keep load-time checking costs low. We report on qualitative and quantitative experience with our implementation of RMJ.
MJ
Authors: Corwin John , Bacon David F. , Grove David , Murthy Chet
Published: November 2005

While Java provides many software engineering benefits, it lacks a coherent module system and instead provides only packages (which are primarily a name space mechanism) and classloaders (which are very low-level). As a result, large Java applications suffer from unexpected interactions between independent components, require complex CLASSPATH definitions, and are often extremely complex to install and maintain. We have implemented a module system for Java called MJ that is implemented with class loaders, but provides a much higher-level interface. High-level properties can be specified in a module definition and are enforced by the module system as new modules are loaded. To experimentally validate the ability of MJ to properly handle the complex module inter-relationships found in large Java server systems, we replaced the classloader mechanisms of Apache Tomcat 4.1.18 [27] with 30 MJ modules. The modified Tomcat is functionally identical to the original, but requires no CLASSPATH definitions, and will operate correctly even if user code loads a different version of a module used by Tomcat, such as the Xerces XML parser [31]. Furthermore, by making a small change to the Java core libraries enabled by MJ, we obtained a 30% performance improvement in a servlet microbenchmark.
Heap compression for memory-constrained Java environments
Authors: Chen G. , Kandemir M. , Vijaykrishnan N. , Irwin M. J. , Mathiske B. , Wolczko M.
Published: November 2005

Java is becoming the main software platform for consumer and embedded devices such as mobile phones, PDAs, TV set-top boxes, and in-vehicle systems. Since many of these systems are memory constrained, it is extremely important to keep the memory footprint of Java applications under control.The goal of this work is to enable the execution of Java applications using a smaller heap footprint than that possible using current embedded JVMs. We propose a set of memory management strategies to reduce heap footprint of embedded Java applications that execute under severe memory constraints. Our first contribution is a new garbage collector, referred to as the Mark-Compact-Compress (MCC) collector, that allows an application to run with a heap smaller than its footprint. An important characteristic of this collector is that it compresses objects when heap compaction is not sufficient for creating space for the current allocation request. In addition to employing compression, we also consider a heap management strategy and associated garbage collector, called MCL (Mark-Compact-Lazy Allocate), based on lazy allocation of object portions. This new collector operates like the conventional Mark-Compact (MC) collector, but takes advantage of the observation that many Java applications create large objects, of which only a small portion is actually used. In addition, we also combine MCC and MCL, and present MCCL (Mark-Compact-Compress-Lazy Al-locate), which outperforms both MCC and MCL.We have implemented these collectors using KVM, and performed extensive experiments using a set of ten embedded Java applications. We have found our new garbage collection strategies to be useful in two main aspects. First, they reduce the minimum heap size necessary to execute an application without out-of-memory exception. Second, our strategies reduce the heap occupancy. That is, at a given time, they reduce the heap memory requirement of the application being executed. We have also conducted experiments with a more aggressive object compression strategy and discussed its main advantages.
Ulterior reference counting
Authors: Blackburn Stephen M. , McKinley Kathryn S.
Published: November 2005

General purpose garbage collectors have yet to combine short pause times with high throughput. For example, generational collectors can achieve high throughput. They have modest average pause times, but occasionally collect the whole heap and consequently incur long pauses. At the other extreme, concurrent collectors, including reference counting, attain short pause times but with significant performance penalties. This paper introduces a new hybrid collector that combines copying generational collection for the young objects and reference counting the old objects to achieve both goals. It restricts copying and reference counting to the object demographics for which they perform well. Key to our algorithm is a generalization of deferred reference counting we call
Ulterior Reference Counting
. Ulterior reference counting safely ignores mutations to select heap objects. We compare a generational reference counting hybrid with pure reference counting, pure mark-sweep, and hybrid generational mark-sweep collectors. This new collector combines excellent throughput, matching a high performance generational mark-sweep hybrid, with low maximum pause times.
Saving the world from bad beans
Authors: Clarke Dave , Richmond Michael , Noble James
Published: November 2005

The Enterprise JavaBeans (EJB) framework requires developers to preserve architectural integrity constraints when writing EJB components. Breaking these constraints allows components to violate the transaction protocol, bypass security mechanisms, disable object persistence, and be susceptible to malicious attacks from other EJBs. We present an object confinement discipline that allows static verification of components' integrity as they are deployed into an EJB server. The confinement rules are simple for developers to understand, require no annotation to the code of EJB components, and can be efficiently enforced in existing EJB servers.
Language support for lightweight transactions
Authors: Harris Tim , Fraser Keir
Published: November 2005

Concurrent programming is notoriously difficult. Current abstractions are intricate and make it hard to design computer systems that are reliable and scalable. We argue that these problems can be addressed by moving to a declarative style of concurrency control in which programmers directly indicate the safety properties that they require. In our scheme the programmer demarks sections of code which execute within lightweight software-based transactions that commit atomically and exactly once. These transactions can update shared data, instantiate objects, invoke library features and so on. They can also block, waiting for arbitrary boolean conditions to become true. Transactions which do not access the same shared memory locations can commit concurrently. Furthermore, in general, no performance penalty is incurred for memory accesses outside transactions.We present a detailed design of this proposal along with an implementation and evaluation. We argue that the resulting system (
i
) is easier for mainstream programmers to use, (
ii
) prevents lock-based priority-inversion and deadlock problems and (
iii
) can offer performance advantages.
A translating computer interface for a network of heterogeneous interactive information retrieval systems
Authors: Marcus Richard S.
Published: November 2005

The need for a network of heterogeneous interactive bibliographic information retrieval systems is projected from the facts of wide acceptance and growing demand for these systems and the limitations of their use caused by limited online data base size. Because of the established characters of the different I-R systems and unlikelihood that a standardized I-R system leading directly to the ultimate uniform network will soon be generally adopted, we propose an intermediate solution in which computer interfaces would provide the networking capability by translating and converting among the diverse languages and data bases of existing systems.We have begun work on such a network in which the computer interface is based on the concept of a common language for commands, indexing vocabularies, and data base structures. In particular, the common language for commands and data base structures is based on identifying the basic or primitive I-R functions and bibliographic data base elements. The conversion among indexing vocabularies is based on the concept of a Master Index and Thesaurus containing the conglomerate thesaurus information from the separate data bases. In addition, the phrase decomposition and stemming of the individual words in the search request and subject index phrases are used as further techniques for automated conversion among diverse vocabularies. An initial experimental interface is described which interconnects the M.I.T. Intrex system, the MEDLINE retrieval system, and the TYMNET computer network using the ARPANET Terminal Interface Processors for intercomputer communication.
Retrieval operations and data representations in a context-addressed disc system
Authors: Su Stanley Y. W. , Copeland George P. , Lipovski G. Jack
Published: November 2005

This paper attempts to demonstrate that simple expansion of the processing capabilities of fixed disc read and write heads can avoid the multilevel mappings from high-level retrieval language to machine language and from user oriented data representation (information structure) to machine oriented data representation (storage structure) which are found necessary in conventional von Neumann computers. The processing capabilities built in the disc read and write heads for each disc track allow information files to be segmented and data items stored on all segments to be searched, modified, inserted, deleted, rearranged and rewritten simultaneously as a set of discs are rotating. Information structures such as the network structure, the hierarchical or tree structure and the relational structure are discussed and their implementations and basic search operations in the disc system are described.
Interactive PL/1
Authors: Zelkowitz Marvin V.
Published: November 2005

An investigation of the PL/1 language in an interactive environment has lead to the discovery of several deficiencies in the language when used as a pedagogical tool. How these deficiencies were eliminated (or avoided) in one particular implementation is discussed.
A case for while-until
Authors: Friedman Daniel P. , Shapiro Stuart C.
Published: November 2005

A new control structure construct, the while-until, is introduced as a syntactic combination of the while and the until. Examples are shown indicating that use of the while-until can lead to structured programs that are conceptually more manageable than those attainable without it. The while-until statement is then extended to a valuereturning expression which is shown to be more powerful than either the while or the until.
Psychological complexity of computer programs
Authors: Weissman Larry
Published: November 2005

In order to reduce the complexity of programs many ideas and techniques have been expounded. However, no quantitative evidence has been given that the quality of the programs has indeed been improved. We believe that experimental studies should be performed to measure those factors which make programs difficult to understand and maintain. The first step in such research is to establish a suitable experimental methodology. This paper describes a series of experiments which have been conducted with the aim of establishing such a methodology.
SYSL
Authors: Terashima Nobuyoshi
Published: November 2005

SYSL-System Description Language, which is a higer level language like FORTRAN, COBOL and so on, has been developed as a system implementation language for use by DIPS-1 operating system, a large scale OS for time-sharing services, banking control services and so on.Run-time efficiency and space efficiency of SYSL object codes are 1.11 time and 1.17 times, respectively, of those obtained from assembly language.SYSL has been used to write about 90 per cent of language processors and other processing programs of DIPS-1 OSSYSL has reduced the huge amount of time required for coding, debugging, maintaining and documenting.
Flowchart techniques for structured programming
Authors: Nassi I. , Shneiderman B.
Published: November 2005

With the advent of structured programming and GOTO-less programming a method is needed to model computation in simply ordered structures, each representing a complete thought possibly defined in terms of other thoughts as yet undefined. A model is needed which prevents unrestricted transfers of control and has a control structure closer to languages amenable to structured programming. We present an attempt at such a model.
Natural laws controlling algorithm structure?
Authors: Halstead M. H.
Published: November 2005

In this preliminary report, a hypothesis is developed to the effect that algorithms, considered as distrillations of thought, may possess a general structure which obeys physical laws. Testing the hypothesis against measurements of published algorithms does not disprove it.
Optimized code generation from extended-entry decision tables
Authors: Woods C. Geoffrey , Hawes Mary K.
Published: November 2005

Optimized algorithms have been developed for the processing of extendad-entry decision tables. and for the direct conversion of extended-entry tables to code without translation of the extended-entry decision tables to limited-entry tables. One of the algorithms is described and discussed in this paper. Examples are given to illustrate why direct code conversion is better, and why it is better. Although the amount of improvement will very from table to table. and indication of the savings is included.
Lisp 1.5 decision tables implemented for a serial computer and proposed for parallel computers
Authors: Schwartz Bennett M.
Published: November 2005

This paper reviews two serial decision table translators that have been implemented in Lisp 1.5 (2, 3) and suggests how similar translators might be implemented on highly parallel computers. The first of the two serial translators, Deftab, is a standard Kirk-algorithm processor that accepts limited-entry decision tables as input and defines Lisp functions as its output. The second serial translator described, Dectab, accepts Lisp 1.5 function definitions and generates equivalent decision tables. Finally, a set of similar but parallel functions is described that could form the basis of a compiler or interpreter system, that produces parallel code from serial programs.
Experimental Trac language primitive to allow user control of the scan algorithm
Authors: Kagan Claude A. R.
Published: November 2005

The Trac language as defined by Calvin Mooers lacks provisions to permit the creation of user-defined functions having the attributes of primitives of the language.
Characteristics of a structured program
Authors: Chapin Ned , Denniston Susan P.
Published: November 2005

Structured programing is the set of design and implementation processes that yield well-structured programs. A well-structured program can be identified by the presence of five positive characteristics, and the absence of two negative characteristics.
Embedding sparse matrix operations in SNOBOL4
Authors: Feldman Michael B.
Published: November 2005

We shall discuss in this paper how sparse matrix operations might be embedded in SNOBOL4, using the programmer-defined function capability, the TABLE datatype, and the APPLY built-in function which allows function names to be treated as variables.
The best simple code generation technique for WHILE, FOR, and DO loops
Authors: Baskett Forest
Published: November 2005

This code generation technique for WHILE, FOR, and DO loops is simple to implement and usually results in the best loop code in the absence of flow analysis. Also the technique makes it possible to move code from inner loops without doing flow analysis and without ever moving code from a less frequently executed block to a more frequently executed block.
The translation of boolean
Authors: Burda John C.
Published: November 2005

The algorithms described in this document were designed for the OLIVER Data Base Management System Compiler. They are superior to previously published results in that they require a single left-to-right scan over the input string while maintaining the generation of optimal transfer logic code for NOT, AND, OR, IMPLIES and the looping of a repeating group operand. Exclusive OR and Equivalence are also recognized and translated by the algorithms.
Another view of coroutines
Authors: Jacobsen Tom
Published: November 2005

A few comments upon the paper given by Mr. Dick Grune in a recent issue of this periodical (ACM SIGPLAN Notices 12.7 1977, p 75--81).
Comment on a paper of R. A. Freiburghouse
Authors: Peschke J. V.
Published: November 2005

This is a comment on the paper 'Proposed Extension~to PL/I for Real-Time Applications' which appeared in SIGPLAN-Notices in July 1977 (pages 26--42).
A comparison of PASCAL and FORTRAN as introductory programming languages
Authors: Nutt Gary J.
Published: November 2005

Many colleges and universities offer introductory programming classes based on the FORTRAN language. Several of these schools are contemplating a change to a more modern programming language in this first course. The Department of Computer Science at the University of Colorado has recently made the transition from FORTRAN to PASCAL, and this paper offers an informal discussion of the experiences of one instructor during that change. It is hoped that others who may be considering a similar change will benefit from our experiences.
Flowcharting by stepwise refinement
Authors: Ferstl O.
Published: November 2005

This paper describes a flowchart technique, which supports the method of program development by stepwise refinement.Flowcharts made by this technique have a tree structure, which simplifies program test and coding the chart into a programming language. For design of the overall control structure the basic forms concatenation, selection, repetition and restricted GOTO statements are available.
Optimization of the compiling of subscripted array references
Authors: Elliott Irving B.
Published: November 2005

A method is described for compiling higher-order-language references to array elements into optimum in-line executable code. Optimization is achieved by resolving parts of the required subscripting calculation, e.g., those which involve constant values, at compile time instead of at run time. The method is applicable to references for arrays of any number of dimensions.
The CAMIL programming language
Authors: Pflasterer David C.
Published: November 2005

This paper briefly descrbes the Computer Assisted/Managed Instructional Language (CAMIL), a language developed for applications in computer assisted and computer managed instruction. The language is general purpose in that it is also usable for systems and applications programming. To provide a truly general purpose capability, a design which divides the language into two sublanguages, Basic and Extended CAMIL, was implemented. Covered in the paper are (1) the portions of the language which are unique to CAMIL and which deviate from the traditional constructs found in many languages (including an implementation of data abstractions which serves as an alternative to the approach taken in CLU and ALPHARD); and (2) short descriptions of constructs available which are similar to or deviate slightly from traditional language constructs.