Abstracts of Accepted Papers

Transcribed from the printed issue; not yet reviewed. Read it in the PDF of the issue, page 13

APL Helps Deaf Person to Hear Again — P. Deslauriers. This paper demonstrates how APL can be an effective tool in the world of research and development of electronic systems by describing the use of APL in the research and development of a cochlear implant device. The device described is a biomedical electronic system which permits a completely deaf person to regain partial hearing capabilities. The paper begins with an overview of the system itself, followed by a discussion of how APL was utilized.

APL Programming without Tears — P. Naeve, B. Strohmeier, and P. Wolf. The authors discuss some of the drawbacks involved in producing APL code, including the lack of general understanding about APL primitives, the lack of familiarity with APL glyphs, and the awkwardness of the traditional process for writing APL code. This last aspect is discussed in detail, with the proposal that Knuth’s idea of literate programming be adapted to APL to produce more readable code. An example is provided to highlight the merits of this application.

Approaching Classical Algorithms in APL2 — F. Grimm and Manspeter Bieri. Classical algorithms and data structures as made popular by Knuth’s The Art of Computer Programming have been largely ignored so far by APL2 programmers. This was understandable to a certain degree in the era of APL, but has lost its justification with the rise of APL2 and similar APL successors. First, the essence of classical algorithms as well as the principal ways of data structuring and accessing are re-examined. Then it is shown how pseudocodes or implementations of classical algorithms can be transferred one-to-one into APL2 almost automatically and often with an acceptable resulting performance. But, in general, the better way consists in maintaining only the general design principle behind a classical algorithm and combining it with the elegant and efficient specific possibilities of APL2. Both approaches are explained and illustrated by means of a typical classical algorithm from picture processing.

APROCL: A Hybrid Language — Dennis Holmes and John E. Howland. This paper describes the design of a hybrid language that combines the features of an array processing language and Lisp dialect in a consistent and useful manner. This language, APROCL (Array PROCessing Lisp) is derived from the J dialect of APL and the Scheme dialect of Lisp. The base syntactic structure is taken from Scheme, while the array processing features are based on the J programming language. A prototype implementation has been made and some experiences with this implementation are described. This implementation uses J as an embedded array processing engine in a Scheme interpreter / compiler.

The language as specified provides a set of data types and manipulation tools that is more diverse than found in either Scheme or J. APROCL allows the programmer to apply array processing functions to lists of arrays in the Scheme style and list processing functions to arrays of lists in typical J style. The result is a language that not only brings array processing capabilities to Scheme, but also significantly extends the functionality of the Scheme language.

ARDA: Expert System for Reliability Data Analysis — Jake Ansell and Julhim Al-Doori. This paper explores the design and implementation of ARDA, an Expert System to analyze reliability data. Initially the knowledge domain is explored for the viability of the system. The philosophy of design of the system is discussed. Details of the implementation are described. There is discussion of extension of the system to other statistical analyses and of using alternative inferential bases.

Array Morphology — Robert Bernecky. Array morphology is the study of the form, structure, and evolution of arrays. An array annotation for a program written in an applicative array language is an abstract syntax tree for the program, amended with information about the arrays created by that program. Array notations are useful in the production of efficient compiled code for applicative array programs. Array morphology is shown to be an effective compiler writer’s tool. Examples of an array annotator in action are presented, showing its value in array morphology. Array morphology is shown to provide methods for static detection of certain classes of programming errors.

Assertions, a generalization of declarations, offer significant benefits to application writers as well as compiler writers. Assertions, and therefore declarations, may be represented as conjunctions, and are, therefore, conforming extensions to ISO Standard APL. A domain conjunction is offered as an example of how assertions might be defined.

Several other points are made relevant to the implementation of array language compilers and interpreters.

Bayesian Methods in APL — Alan Sykes, A. Mayer, and T. Stroud. This paper explores the ideas of Bayesian Statistical Inference from the point of view of statistical computation. As such the paper is largely self-contained, enabling those more familiar with APL than statistics to understand the basic statistical methodology and appreciate its strengths. The paper further reports on recent collaborative work in providing a computational framework in APL for extending Generalized Linear Models to their Bayesian counterparts. This work relies heavily on methods for numeric integration combined with the iteratively re-weighted least squares procedure at the heart of the Generalized Linear Models as incorporated into ASLGREG, the first volume produced in ASL (the APL Statistics Library).

Building the APL Atlas of Natural Shapes — Gérard A. Langlet. It was previously shown that APL contained the most powerful idiom ≠\ that could be used, directly in the language all computers know: binary algebra, to build models as well for physics as for biology and computer science. Several papers on the subject were published or submitted inside the APL world as well as outside. The purpose of this paper is to show how a classical model, built to generate fractal shapes in plane geometry (2-D) can be revisited and considerably extended, thanks to the properties of ≠\ and of array-oriented binary algebra.

Compiling APL to SISAL — Robert Bernecky. Compiling APL is problematic. The freedom APL grants to programmers, to dynamically redefine the type, rank, and shape of an array, and to redefine functions on the fly, is antithetical to the strict requirements of traditional compiler design. That freedom also happens, perhaps not coincidentally, to make iterative APL code run hundreds of times slower than compiled traditional code. SISAL, an applicative array language, has solved several of the problems of compiling array languages, and is beating Fortran on a number of supercomputer benchmarks. This paper presents the challenges of compiling APL programs into SISAL and recommendations for solving some of the problems which occur in such a translation. Several benchmarks are proposed for comparing interpreted and compiled APL.

Confessions of Two APL Educators Learning J — Murray Eisenberg and Howard Peelle. The paper reports how two university teachers of APL began to learn J. By presenting accounts of a series of small experiments, it reveals our understandings and misunderstandings along the way. It discusses things we especially liked and disliked about J and the resources available for learning it, and indicates some possible implications of our experience for teaching J.

Co-operative Programming with Windows DDE — Adrian Smith. In the past, there have been two kinds of APL applications: one-off investigative developments, and major vertically integrated applications. The first kind are usually characterised by a small volume of powerful APL code, precisely targeted towards exploring an interesting business idea. The second kind are typically wrapped around with a great blanket of user code, which is all about the entry, validation, and presentation of data.

With the advent of MS Windows (and the inevitable move of the PC community toward Windows applications) we can begin to exploit the inherent power of Word and Excel as native components of our APL development. This paper begins the exploration, with just two simple ideas: an APL button-bar for Excel (for Excel freaks who have begun to want a real array language), and an Excel-based formatting tool (for APL freaks who get bored with laying out neat reports).

Discriminant Analysis — Eero Korpelainen. Abstract not available at time of printing.

Distributed Computing in the Workstation Environment — Johann Mitlöhner. Exploiting unused processor time in workstation environments can result in large performance gains in user applications. Techniques for implementing client-server based distributed processing are shown. A time-consuming algorithm is sped up by using idle workstations in a local area network as APL servers.

Efficient Maximum Likelihood Estimation of Linear Models with APL — Frank C. Ripley. Maximum likelihood estimators used in statistics and econometrics have desirable properties; however, due to the complexity of their solution maximum likelihood techniques are not widely used. This paper examines an APL implementation of one of the most efficient algorithms used to estimate the parameters of the univariate ARMA process. The straightforward use of APL is found to be unacceptable and so a systematic search for optimization is made. This search results in an approximate solution for the ML estimator, the use of ⎕NA and FORTRAN, and special matrix techniques to increase the efficiency of the algorithm. The matrix techniques used are implementations of sparse, banded, and block diagonal data structures. Additional matrix techniques involve incremental updating of matrices. The effect of these optimizations is to bring the computational cost from an O(N^3) problem to an O(N^1) problem. This translates into a significant reduction in computer requirements. For example, to estimate a six-parameter ARMA model with 5000 observations, memory requirements fall from approximately 95 Mb to 300 kb. Computer time falls from about 400 years to about 2 minutes.

Extending APL2 to Include Program Control Structures — David A. Selby. APL language designers have always argued that implicit control flow beyond that of the branch arrow and array operations is not required in the APL2 language definition. On the other hand, computer scientists object to APL on account of the lack of control flow within its basic language definition. The first thing a reader looks for in trying to understand a program in any language is its control flow. Given the wide variation in conditional branch idioms in APL2, and the lack of line blocking, it is often difficult for even a skilled reader to get a clear understanding of a previously unseen APL function.

This paper proposes the addition of various well-established program control flow structures into the APL2 language as reserved words.

Extending the APL Character Set — James A. Brown, Brent Hawks, Ray Trimble. APL is often presented as a notation that is independent of national language because of its symbolic nature. Paradoxically its unique character set has led to APL being treated as if it were itself a national language. This has meant, in many practical situations, that the APL character set is incompatible with national language character sets.

IBM’s APL2 attempted to avoid these problems by defining a set of extended (31 bit) characters, and this has indeed been helpful in handling Asian languages such as Kanji. But the character mappings adopted have not been adequate to support all European and Middle Eastern language characters, nor have they been consistent across platforms.

With the advent of international standards for character assignment, there is an opportunity to create APL systems that handle the character sets of the world in an efficient and elegant manner. While at first the solution appears to require only a recitation of code point assignment, an analysis of the problem leads to interesting and disturbing questions about a number of APL system functions, system variables, commands, and file facilities. This paper explores problems with internal conversions, external representation, migration, compatibility, and interplatform portability.

Extending the Two-Partner Shared Variable Protocol to n Partners — Thomas Kolarik. APL as a language has always provided a high level of abstraction to its users. Only in the field of communication APL channels — called shared variables — have been restricted to at most two partners. As most distributed applications demand more than two interacting programs, APL users had to use their own techniques, like client-server, to develop applications that share information among more than two partners. This paper presents a proposal to move the administration of shared memory from application to language level: an extension to the well-known shared variable protocol to share memory among more than two partners. A programming technique — replicated workers — and a sample application for students that learn APL in a working group are shown that take advantage of this feature. These are both based on a prototype implementation of the proposed protocol.

From Trees into Boxes — David H. Steinbrook and Eugene McDonnell. This paper is a progress report on work undertaken to include tree data structures by means of the boxed data type available in J. Methods for displaying these boxed arrays as trees are shown. This work is part of a larger effort to provide a comprehensive set of facilities in J for working with tree structures. The facilities described were at first modelled in J and subsequently translated into C, in order to provide a J interpreter which has trees as native facilities. Thus this work also exemplifies the way in which one can tailor the J interpreter to special needs.

Identification of Parallelism in Neural Networks by Simulations in the Language J — Alexei N. Skurikhin and Alvin J. Surkan. Neural networks with back-propagation training are designed and expressed in the language J, an APL derivative with very powerful function encapsulation features. Both the languages J and APL help to identify and isolate the parallelism that is inherent in network training algorithms. Non-critical details of data input and derived output processes are de-emphasized by relegating those functions to callable stand-alone modules. Such input and output modules can be isolated and customized individually for managing communication with arbitrary, external storage systems. The central objective of this research is the design and precise description of a neural network training kernel. Such kernel designs are valuable for producing efficient reusable computer codes and facilitating the transfer of neural network technology from developers to users.

Introduction to Log-Linear Analysis and Implementing Newton-Raphson Algorithms in APL2 — Duncan McArthur. This paper introduces the method of log-linear analysis for performing hypothesis testing on contingency tables. The reader will see a brief development of this topic beginning with Pearson’s classic chi-square test and using examples of analyses on two- and three-dimensional tables. The idea of hierarchical models and backward elimination are discussed. Finally, the APL2 implementation of the Newton-Raphson algorithm is described. Newton-Raphson is an iterative procedure for finding the roots of a function. It is used in log-linear analysis to find the maximum likelihood estimation of expected frequencies which cannot be calculated from expressions in closed form.

JVOX — David G. Smith and Joey K. Tuttle. It is easy to learn J; just talk to your computer. Voice recognition technology is already on the desktop. You can use voice input to bypass some common obstacles and promote gratifying and enjoyable experimentation with the language. It is possible to avoid pawing through references to find an elusive construct. Just talk, and anything from simple primitives to complex idioms can appear on your computer screen. Spelling and typing errors are all but eliminated, and talking constantly reinforces the new notation’s meaning.

This paper presents results from some experiments with a JVOX prototype. The presentation includes a demonstration.

Learning Modern Algebra — Pavel Luksha. The study of modern algebra, especially that of finite fields and their application to error codes is aided by the use of a computer. This paper is an account of how a high school student put APL to good use in a self-study course in this University level subject. There is a review of finite algebra, a short discussion of finite fields, a discussion of polynomials over those fields, and their use to construct error-detecting and error-correcting codes.

Modern APL Windows — Richard R.N. Eller. Windows 3.1 represents the biggest revolution to APL technology since the advent of full-screen techniques. This creates a new challenge to APLers migrating their applications from mainframe or PC-DOS environments into Windows 3.1. This paper describes an easy means to adapt existing and new applications to exploit Windows Graphical User Interfaces (GUI). By using the techniques described below one can utilize most GUI features without needing to comprehend the massive amount of detail typical of Windows programming. Additionally, any application will also be backwards compatible to the DOS character-based screen interface.

A Parallel Topological Feature Map in APL — J. Frey, D. Scheppelmann, G. Glombitza, H.P. Meinzer. One can distinguish two different approaches to neural networks. The supervised networks and the self-organizing or unsupervised neural networks. The first type of neural nets is supplied with an ideal result regarding the input. During the learning procedure the neural net adjusts weighting factors of the links between neurons so that the input feature vectors map to the ideal output. Those nets are used for example in robotics, where the ideal result is well known: it is the position the robot should be placed in. For the cases where no ideal result is known, the second type of neural nets, the so-called self-learning Topological Feature Map (TFM) is appropriate. This paper will introduce such a neural net based on the idea of Kohonens TFM. The original algorithm was extremely sequential and therefore not suitable for an APL implementation. The parallelization of the algorithm led to important improvements regarding speed and convergence to the global optimum.

Point-wise Calculus — Walter G. Spunde. The work of Richard Neidinger implementing differentiation in APL as a vector arithmetic is reformulated and extended, for functions of a single variable, to nested vectors whose components hold the values, at any number of given sample points, of a function and its derivatives up to any specified order. It is argued that, for teaching purposes, this sampling provides a more intuitive introduction to mathematical functions and the rules of calculus than do algebraic formulae, and that for certain calculations (such as the computation of polynomial approximations of high degree) the formulation provides superior algorithms for computation. As such, it offers an alternative approach to the teaching of elementary college mathematics.

Roles of APL in Military Satellite Surveillance — Jack G. Rudd. APL has had a significant prototyping role in military satellite surveillance for more than two decades. This paper begins by describing the success of the Defense Support Program in alerting the Patriot antimissile batteries of incoming Scud missiles in the Persian Gulf War. Subsequently it describes the prototyping role of APL on the Defense Support Program and other satellite surveillance programs. Several observations are made along the way contrasting project development methods involving APL prototyping with other methods of project development. The paper concludes by describing two new efforts: one which features rapid development and delivery of APL2 analysis programs on workstations for direct use by military customers; and one which uses APL2 to study and prototype specific military applications for potential implementation on a massively parallel processor.

Rolling Dice: Some Notes on J and Teaching Probability — Keith Smillie. This paper shows how J might be used in a course in elementary probability. All examples are concerned with rolling dice, but the dice may have n sides, and be used to play music!

SCARFS: An Efficient Polynomial Zero-Finder System in APL — Tien Chi Chen. This paper introduces SCARFS (Symmetric Cluster-Adapted Root-Finding System), a new efficient APL workspace for general polynomial iterative zero-finding, as a practical outcome of our study of global iterative zero-finding. The 25 functions in this workspace are coordinated by the SCARF function with iterations performed by the function SCATTER (Symmetric Cluster AdapTed iTERation).

Solving Polynomials in Two or Three Variables — R.G. Selfridge. An algorithm is described that allows two polynomials in two variables to be reduced to a single polynomial in one variable, and then back-solved to get all sets of solutions. The algorithm works faster than most other algorithms within its range of utility (providing sets of solutions as large as 70), and can be extended to cover some sets of three polynomials in three variables (those where one of the polynomials has only two of the variables). While subject to the known stability problems of polynomial root-finding, this algorithm can also be extended to provide for reducing to the single variable polynomial with symbols, thus permitting proof of results, and potential removal of extraneous roots. Such manipulation can then materially shorten the numerical process if the problem is to be applied to a number of different cases.

Structured APL: A Proposal for Block Structured Control Flow in APL — Robert Willhoft. APL, although a very powerful language, has failed to gain wide acceptance in part due to its lack of control structures. A proposal is made for introducing structure in APL objects by adding to the items that can be located on the left side of the colon (:). These markers show the beginning and end blocks of code and allow for selection, iteration, and termination. The set of control structures is shown to be robust by showing their use in the creation of traditional control structures. A method of conversion to ISO APL is also presented.

This paper briefly discusses proposals that have been made in the past along with an evaluation of their merits and shortcomings. The paper ends with a discussion of related issues, including elimination of branching, introduction of definition blocks, and lexical scoping in APL. Several areas for continuing work are given.

Structuring Functions with Operators — David Eastwood. This paper draws its inspiration from a theme that has been popular at APL conferences over the years. This is an attempt to introduce some or all of the elements of structured programming into the APL language either via extensions to the language or via the adoption of some set of programming standards. In view of the speed and frequency with which agreed extensions to the APL language take place, it must be a reasonable assumption that there is no immediate likelihood of APL acquiring new flow control primitives. The programming standards approach relies heavily, however, on the willingness of the programmer to follow them and much good work can be undone by a few minutes of hasty coding to fix a last-minute error.

Talking with APL via DDE: Teaching an Old Dog New Tricks — Steven J. Halasz and Andrei Kondrashev. Shared variables and auxiliary processors are well-known techniques for connecting alien applications and facilities to APL. The use of APL in the PC windowing multitasking environment of MS Windows, which incorporates a messaging model for interprocess communications, requires some new approaches to the implementation of shared variables and auxiliary processor support. Any such implementation should realize the maximum opportunities that the windowing environment offers.

This paper presents a shared variable interface to MS Windows graphics written in C and a simple charting package called TinyPlot written in Dyalog APL for Windows. The purpose of this paper is to demonstrate and investigate the Dyalog APL shared variables and auxiliary processor facilities, and to offer observations and conclusions about the benefits, limitations, and potential of DDE and DLL interfaces generally.

The Testing of an APL Compiler — Wai-Mee Ching and Alex Katz. The testing of the APL-to-C compiler, COMPC, developed at T.J. Watson Research Center consists of two components: a testing suite of 146 APL programs collected from various sources covering a variety of fields, and a unit-testing procedure which tests each primitive function on all possible subcases arising from different combinations of storage types and shapes. The second component, unit-testing, is an interesting example of the productivity APL can provide for software development. The unit-testing procedure is based on a workspace written in APL and utilizes the ⎕FX feature of APL to create a test function dynamically from one of several templates. The testing of both components is automated through the use of control programs written in a command language under the VM/CMS operating environment.

Transfinite Nesting in Array-Theoretic Figures, Changes, Rigs, and Arms. Part I — Trenchard More. Transfinite Nesting in Array-Theoretic Figures, Changes, Rigs, and Arms. Part II — Trenchard More. Abstract not available at time of printing.

Adaptive Learning Networks in APL2 — Alexander O. Skomorokhov. Adaptive Learning Networks (ALN) method is a tool to solve the problems of modelling, prediction, diagnosis and pattern recognition in complex systems. ALN is similar to neural network techniques, with the main difference being self-organization of network structure on the base of generation and estimation of various nodes, connections, and weights. A set of functions presented in the paper shows that ALN are simply realized in APL2. User-defined operators are used as a very convenient tool for ALN programming. The paper discusses application of implemented software to the problem of Burnout Heat Flux prediction in nuclear reactors. It is shown that the ALN technique allows prediction of Burnout Heat Flux with approximately three times better accuracy than commonly used methods.

Understanding ANOVA the APL Way — Norman Thomson. Statistics textbooks expound the collection of techniques known as analysis of variance by using mathematical formulae. The term analysis of variance is something of a misnomer, since any analysis follows a primary exercise of partitioning sums of squares, that is entirely a matter of computation and data reorganization of the sort at which APL2 is uniquely adept. The crux of the analysis stage then consists of making choices between what is often a bewilderingly large range of subtly different sums of squares partitions. The primitive function enclose with axis maps naturally into the data manipulations involved in sums of squares partitions for arrays. To the casual reader the latter are obscured rather than clarified by the use of mathematical formulae alone. This paper explores the relationship between APL2 functions and ANOVA, and goes on to illustrate how these can be used in the context of a designed experiment.

Using Defined Operators and Function Arrays to Solve Non-linear Equations in APL2 — Stephen M. Mansour. There are many mathematical algorithms such as Newton’s method used to calculate solutions to non-linear equations. This paper will show how easy it is to implement these algorithms in APL2 with a minimum of code using the defined operator and careful design of its input functions. The emphasis in this paper is on the method of developing an application using APL2 and the concepts of defined operators and function arrays. This requires that input functions be robustly designed to take arrays as arguments and to produce array results much like primitive scalar functions. In this manner one can minimize the number of calls to the input function and take advantage of APL2’s array handling capabilities. Since operators are permitted at most two operands, it is critical to minimize the number of input functions. This requires the input function designer to think in terms of function arrays. Although function arrays are not yet part of the language, they can easily be defined in most any version of APL.

The Workspace Manager: a Change Control System for APL — Rexford H. Swain and Daniel F. Jonusz. This paper describes the Workspace Manager (WSM), a tool that helps to support and add discipline to APL system development and maintenance efforts. The WSM acts as a repository of APL objects (variables, functions, and operators). Programmers use WSM tools to find where objects are used, edit objects, save changed objects, and request that objects be installed into (or erased from) production workspaces. Periodically, the WSM installs new releases of production workspaces by merging new and changed objects into existing workspaces. Audit trails are maintained for all of these activities, making it possible to review the change history of an object, compare different versions of an object, compare different releases of a workspace, revert to an old release of a workspace, and so on.