bluuebunny/crossref_metadata_2025_split huggingface dataset:
Applications of pipelining to firmware
Authors: Proulx David M. 
Published: January 2007

It has been found that pipelining at the firmware level of machine organization can provide significant execution time benefits for certain types of instructions. The essential concept involved with this approach is the pipelining of operations within the hardware under direct control of the firmware, rather than the pipelining of microinstructions. Specifically, multiple data values exist within the machine's datapaths which have undergone different amounts of processing.
This paper describes the application of these techniques to a specific pipelined computer. A brief description of the system level pipeline is provided with two examples of the firmware pipeline approach. The operations of floating point normalization and memory transfers have been described in detail.
An improvement of trace scheduling for global microcode compaction
Authors: Su Bogong , Ding Shiyuan , Jin Lan 
Published: January 2007

Fisher's trace scheduling procedure for global compaction has proven to be able to produce significant reduction in execution time of compacted microcode, however extra space may be sometimes required during bookkeeping, and the efficacy of compaction of microprogram loop is lower than that of hand compaction.
This paper introduces an improved trace scheduling compaction algorithm to mitigate the drawbacks mentioned above. The improved algorithm is based on a modified menu of moving microoperations, an improved trace scheduling algorithm, and a special loop compaction algorithm. Preliminary tests indicate that this global compaction algorithm gives shorter execution time and less space requirement in comparison with Fisher's algorithm.
Control system development tools
Authors: Kimbrough Scott 
Published: January 2007

This paper provides a core of APL algorithms for control system development and demonstrates their use by solving a typical control problem. In doing so it outlines useful numerical techniques for simulating dynamic systems and for solving some of the central equations of control theory.
Although some sections of the paper are addressed to APL2 users, the majority of the paper applies to APL. Moreover, by doing a little extra work to handle complex numbers and by installing a “callable” compiled eigenvalue-eigenvector routine, all of the material presented can be adapted to any APL system.
While APL is a comfortable environment for control system development, APL2 contains two especially useful enhancements: 1) complex numbers included in a natural way, and 2) the function EIGEN.
APL2's facility with complex numbers permits the direct and clear coding of frequency domain methods such as root locus, bode plots, and the generation of transfer functions. APL2's facility with complex numbers also makes it possible to include a native eigenvalue-eigenvector utility function, EIGEN. This function generates the eigenvalues and eigenvectors of general square matrices, which can then be used for root locus studies, for transforming system equations to canonical forms, and for efficiently solving the Riccati and Lyapunov equations.
Non-EIGEN-based functions are also provided so that all APL users will find enough tools to model, simulate, analyze, and develop regulators, observers, and filters for linear dynamic systems.
An integrated microprogram development methodology based on APL
Authors: Jacobs Jan W. M. , Hacking Roger J. H. 
Published: January 2007

This paper describes a development methodology for generating code for a microprogrammable processor.
The development system is built around a formal model of the required functionality and some tools that automate, to a large extent, the generation of the final microcode. The tools include the generation and validation of the model, the generation of the symbolic microcode and an assembler for translation into the final microcode.
The main advantage of using this method is the reduction in development time and the removal of all logic errors in early stages of the design (prototyping).
Using the LOGOS programming environment—a case history
Authors: Chapman Steve 
Published: January 2007

LOGOS is a unique programming environment for the APL language. It provides a uniform framework within which APL systems can be created and maintained. This paper describes how LOGOS is used to manage and maintain a large, Sharp APL-based information management system, VIEWPOINT.
A brief overview of both LOGOS and VIEWPOINT is presented, and the steps taken to retrofit VIEWPOINT into the LOGOS environment are traced. Emphasis is placed on the practical considerations and consequences of the conversion, and how the facilities of LOGOS are used in practice. Examples are given to demonstrate the effect LOGOS had in changing the way problems relating to the organization and management of VIEWPOINT were approached and solved. Finally, the paper describes areas in which LOGOS provided techniques to solve problems that might not otherwise have been addressed.
AUTOMAT, an end-user approach in handling applications as multi-dimensional arrays
Authors: Monnier Jean Marie 
Published: January 2007

“AUTOMAT” is an end user, general purpose tool developed initially in APL-SV currently running under VSAPL and APL2 (IBM PC version currently under consideration).
The basic underlying concept is to tap the power of APL in handling multi-dimensional arrays, and make it available to the end user in a very natural and intuitive fashion.
The productivity gains generated by the system are extremely high, as a new application can be set up in terms of fraction of hours, with immediately usable results.
A lot of provisions have been made to handle instantaneously any changes in the structures, whether they are due to new business requirements or to initially overlooked facts.
The system has been and still is successfully used for Data consolidation / analysis, Planning Models and application prototypes. The use of APL as internal language enables the system to communicate very easily with other applications (e.g. Graphics).
Function arrays
Authors: Bernecky Robert 
Published: January 2007

A functional enclose operator, which returns the scalar representation of a function, is introduced. By providing a scalar representation of a function, functional enclose provides capabilities similar to those of SHARP APL Packages. When used in conjunction with the formatting function, functional enclose supplants (@@@@)cr.
Apply is defined as a proper extension of the execute (@@@@) primitive function to the domain of enclosed function and array arguments. Apply, in conjunction with functional enclose, extends the architecture of APL from SIMD [Single-Instruction , Multiple-Data] to MIMD [Multiple-Instruction, Multiple-Data], by allowing creation and concurrent execution of 'arrays' of functions. This provides a concise facility for the establishment of concurrent processes within a single APL task.
Additional extensions allow these processes to communicate via shared variables, permitting the logical creation of arbitrary interprocessor connections, and facilitating the synchronization and control of such processes. Apply provides a hardware-independent way of describing various MIMD architectures, such as banyan- or cube-connected machines, and dataflow machines.
A.P. 1 APL.68000's local auxiliary processor mechanism
Authors: Cleave A. Van 
Published: January 2007

This paper will discuss the implications, uses, and internal architecture of APL.68000's Auxiliary Processor 1, a special auxiliary processor which allows users to create their own
local
auxiliary processors.

As microcomputers become more and more sophisticated, it is increasingly important that APL systems on micros can interface to the “outside world” in as general and as simple a manner as possible. There are three key things that the APL user on a micro needs to interface with:
1) Peripherals
2) Operating System Routines
3) Non-APL Sub-routines (Assembler, Fortran, etc.)
A microcomputer APL*PLUS system implementation
Authors: Gates Phelps 
Published: January 2007

The APL*PLUS/80 System, completed in early 1982, is the most complete microcomputer implementation of APL to date. It includes all of the traditional APL language primitives and most of the STSC APL*PLUS system enhancements. This paper considers some of the problems we encountered in squeezing an APL system of this size into a small computer and the stratagems used to overcome the problems. We then discuss some of the ways in which a microcomputer implementation gives opportunities to increase the usefulness and user-friendliness of APL in ways that are not possible or appropriate in a mainframe implementation.
We chose to make some aspects of the implementation as easy as possible by designing the system for a single target machine, the Radio Shack (TM) TRS-80 (TM) Model III. This computer was chosen for its speed, features, and low cost. The summer 1982 list price for a typical configuration of hardware and software is $2590 (without printer).
The use of APL primitives and function domains to produce general APL solutions to problems involving discontinuities
Authors: Julian Warren G. 
Published: January 2007

There are many mathematical problems where discontinuities or varying boundary conditions mean that a number of different solutions can apply, depending upon the domains of particular variables. In traditional algebra these solutions are usually listed as a set of solutions with the domains of the variables stated for each solution. In programming a similar technique is involved, using branching to select the expression to be evaluated depending upon the domains of the variables involved.
By using APL, both as an algebra and as aprogramming language, single expressions for many such problems can be written (general solutions) which are valid for all variable domains. These solutions are generated using APL primitives to control either the domain of a function or its result.
The paper will discuss the philosophy of the method and its application in simplifying the algorithmic solutions of problems involving restricted domains and discontinuities. Examples relating to the determination of shear forces and bending moments on isostatic beams and utilisation factors (used in electric lighting design) are used to demonstrate the generation of a general solution to a problem involving both restricted domains and discontinuities.
Array diagrams and the Nial approach
Authors: Schmidt Fl. , Jenkins M. A. 
Published: January 2007

The Nested Interactive Array Language, Nial, combines APL and LISP concepts and is based on the theory of nested rectangular arrays. Array theory provides a concise mathematical model of data capturing the essence of everyday data objects. Arrays are displayed by diagrams, which provide an easily comprehended way of communicating the rectangularity, nesting and content of arrays.
A novel drawing technique is presented in which any array diagram can be drawn by combining only three kinds of primitive diagrams according to a few simple rules. The properties of the primitive diagrams and the consequences of the combinatorial rules are studied and exemplified.
The application of an APL micro computer solving a commercial problem - a case study
Authors: Ward H J , Hurdley P W 
Published: January 2007

This paper examines, in detail, three systems originally running on a major APL timesharing service which have been re-developed to run on an MCM APL micro computer complex for BL - a major British motor vehicle manufacturer.
Four aspects of this re-development project are considered:
a) The background to the project, why re-development was considered and the selection of the computer equipment.
b) Appraisal of the three systems and the analysis performed on each - its use; its cost; its size; its operational environment and its overall suitability for the micro computer option. Advantages of a new approach and the development of specific tools to provide the service levels expected by time-sharing service users.
c) Systems design and the influence of a changing user environment and the constraints imposed by a micro computer.
d) The user's point of view in respect of:
- additional and changed responsibilities
- field support
- the user/machine interface.
In conclusion, the suitability of the solution and its development policy is reconsidered after some months of use. Problem areas seen with the benefit of hindsight are now identified and some ideas are put forward in an attempt to avoid them in future.
Using an APL micro computer for distributive processing
Authors: Browne Sandra L. , Browne Adrian 
Published: January 2007

There have been significant changes in computer technology since the authors of this paper started working in APL in 1969. From our point of view the most exciting recent event has been the development of APL for use with micro computers. The increasing power of low cost micros in combination with a good communication facility between the micro and the time sharing main frame make it possible to use micros for distributive processing in APL systems.
This paper describes how the authors altered the system design of an existing time sharing APL system to include a micro, and the type of communications facilities which had to be developed for the micro so that no change in data entry procedure was observed by the operators of this system.
The introduction of a micro which cost as much as a terminal cut system running cost by one third, paying for itself in less than six months.
Parsing and evaluation of APL with operators
Authors: Georgeff M. P. , Fris I. , Kautsky J. 
Published: January 2007

The importance of operators in APL is now well recognised, and considerable attention has been paid to the inclusion of more general operators into the language. In this article we consider some of the consequences for the implementation of interpreters and compilers for APL.
We first consider the difficulties that arise with the introduction of function valued and basic valued operators. We then discuss various modifications to the syntactic and semantic structure of APL that serve to avoid these difficulties. Abstraction operators as in the lambda calculus are also introduced. Finally, we describe an abstract machine for interpreting APL-like expressions which is analogous to the SECD machine used in the lambda calculus.
Graphical data structures in APL
Authors: Hardwick Martin 
Published: January 2007

The continuing reduction in the price of graphics terminals has led to greater interest in graphics and computer aided design. This trend has in turn focussed attention on methods of modelling graphical data using programming languages and databases. This paper presents a method of defining, analyzing and transforming graphical data using an extended APL notation.
The fundamental extension this notation makes to APL is to allow the items in an APL array to have a user defined data structure. A consequence of this extension is that the items in an array can now represent graphical entities such as circles, lines, points etc. In conventional APL an item in an array must be either a number or a character. In this extended notation an item in an array might be a structure designed to represent a point, or a circle, or any other entity.
Programming development control system
Authors: Juvonen Erkki 
Published: January 2007

In an effort to optimize Cobol conversion from one environment to another, an APL system to automate various phases of the conversion was employed. This system performed a lot of actual Cobol code conversion itself, as well as managing flow of Cobol programs from one phase of conversion to another. A pleasant side effect to this approach was the minimization of labor necessary to convert the Cobol code. Manually, a tedious chore, the automated conversion required far less manual effort than initially estimated for the entire conversion project. Many APL processed programs require no programmer effort to complete, while most programming required minimal hand work after the APL phase was completed.
An excercise in running mixed environment - APL, non-APL, interactive, batch -, this effort was a practical and economical approach to the problem at hand.
Generic programming
Authors: Kay Alan C. 
Published: January 2007

Early generic concepts in programming languages were mixed-type arithmetic (e.g., “+” used with any combination of fixed- and floating-point numbers) and “print” functions which could be applied to any of a language's objects. Generic concepts reduce the number of terms which must be remembered and permit considerable condensation of language design. Three different paths in the development of generic-concept languages have been followed by APL, Algol 68, and object-oriented languages such as SIMULA 67 and Smalltalk. APL was the earliest and one of the most interesting applications of generic-concept methods, but now makes the weakest use of these ideas.
My talk will use slides and movies to show how the message-object programming system Smalltalk makes use of generic concepts embedded in class descriptions to give rise to a wide variety of simply programmed dynamic simulations including graphic animation, music synthesis, document layout and retrieval, and APL-like calculation features. Many of these systems have been brought to life by child and adult novice programmers.
A short list of references is given for those wishing more introductory information about Smalltalk.
Predicting the profitability of life insurance products
Authors: Mannacio Eugene R. 
Published: January 2007

Predicting life insurance profitability is accomplished by making assumptions about parameters such as mortality, lapse rates, and expenses. These assumptions are used to project statutory profits, GAAP profits and model office results.
We have developed an APL system which allows our actuaries to test the profitability of an insurance product for a variety of assumption sets. This system has simplified the process of specifying which assumptions are to be used and has fully automated the calculations. In doing so, it has virtually eliminated our need for special actuarial packages and has reduced the time needed to price life insurance products.
This paper examines some considerations faced in the design and definition of this system.
Mesa from the perspective of a designer turned user
Authors: Mitchell James G. 
Published: January 2007

The Mesa language and run-time environment were designed for the purpose of building systems programs such as compilers, operating systems, graphics software and so on. It is a relatively high-level language with strong type checking and supports the ideas of modular programming and abstract data types. Although the system is compiler-based, one can debug programs interactively in source-language terms.
The language has been in rather heavy use since 1976 by a programming community of a few hundreds of professional programmers within the Xerox Corporation, and a large amount of code has been written in it. This talk will give a designer's retrospective view of Mesa from the vantage point of a serious user and will attempt to evaluate its strengths and weaknesses as a vehicle for systems programming.
Array theory in an APL environment
Authors: Hassitt A. , Lyon L. E. 
Published: January 2007

Trenchard More has proposed an array theory which offers a powerful set of operators and operations on nested arrays. We have written a program called Array Theory/370 (AT/370) which implements these array theoretic operations at the assembler-language level on an IBM/370. We have also written a VS APL auxiliary processor which enables the APL user to access AT/370 and to manipulate nested arrays.
This paper describes the simple but powerful APL-AT/370 interface and illustrates how the interface was used to build an interactive array-theoretic system.
Structured development of menu-driven application systems
Authors: Sigle John , Howland John E. 
Published: January 2007

Presenting the user of an application system with a menu of choices is a valuable approach to the human interface problem. In a complex system this may take the form of a tree of menus that is presented. This tree of menus can also be used as the basis for a top-down development of the application system. This paper describes a programming system which can be used to acquire the tree of menus and structure the development of a menu-driven application system in a top-down fashion.
Objects called augmented menus contain not only the textual representation of the choices presented the user (in three forms), but also the action to be taken for each choice. A menu-manager program accesses the specified augmented menu, displays the choices and executes the selected action. This function eleminates much of the work of the application developer.
This development system is illustrated with three applications: an information storage and retrieval system, a class-roll record-keeping system and a text-editing system.
The MACSYMA system for formula manipulation
Authors: Moses J. 
Published: January 2007

MACSYMA is a large LISP system which performs symbolic manipulations such as differentiation, simplification, integration and solution of equations with parametric coefficients. After exhibiting various examples of the system, we shall present some of the data representations used by MACSYMA to model abstract algebraic structures such as polynomial rings.
Two references are given for those wishing more introductory information about MACSYMA.
An overlaying method for the effective organisation of APL systems
Authors: Crossley A D , Streeter G R 
Published: January 2007

A system has been developed to manage the workspace with an application operating under its control. The system, known as PROGRAMSYSTEM, utilises a novel overlaying technique to limit workspace contents to those which are pertinent to the current processing task.
Having been evolved over the past two years, it is currently managing three large operational applications in different organisations, using Sharp APL and Xerox APL.
The paper briefly reviews some popular workspace-management methods using program files, and introduces the concept of Sharp-APL 'packages' on which PROGRAMSYSTEM was based. A characteristic of conventional methods is the use of a directory reference table to locate required objects on the program file. PROGRAMSYSTEM dispenses with this relatively expensive approach. Instead, small functions are generated for the application, which directly reference overlays on a program file; by localising overlay contents within these functions, they are automatically removed from the workspace on termination.
The methodology is explained in detail, and demonstrated by example. The structure of the program file is described, including the additional facilities supported by PROGRAMSYSTEM, these being: collection of cost statistics, handling of graphics and terminal characteristics, and extensive automatic documentation capabilities.
The performance implications of thread management alternatives for shared-memory multiprocessors
Authors: Anderson T. E. , Lazowska D. D. , Levy H. M. 
Published: January 2007

Threads (“lightweight” processes) have become a common element of new languages and operating systems. This paper examines the performance implications of several data structure and algorithm alternatives for thread management in shared-memory multiprocessors. Both experimental measurements and analytical model projections are presented.
For applications with fine-grained parallelism, small differences in thread management are shown to have significant performance impact, often posing a tradeoff between throughput and latency. Per-processor data structures can be used to improve throughput, and in some circumstances to avoid locking, improving latency as well.
The method used by processors to queue for locks is also shown to affect performance significantly. Normal methods of critical resource waiting can substantially degrade performance with moderate numbers of waiting processors. We present an Ethernet-style backoff algorithm that largely eliminates this effect.