Artificial Life Evolution in a Simplified APL2 Environment

Artificial life based on simulation evolution is a flourishing field. One of its most publicized achievements of the nineties was TIERRA, by T. S. Ray. APL2 has been used successfully to implement a similar simpler artificial life application that shows most of the interesting features of TIERRA in an efficient way, providing a modifiable environment where it is easy to experiment.

Using APL2 to Compute the Dimension of a Fractal Represented as a Grammar

In this paper we describe the use of APL2 to implement and depict the equivalence between the mathematical field of fractal curves and the linguistic field of parallel derivation grammars, by tackling the problem of determining the dimension of a fractal from its representation as a grammar. APL2 makes the required computation quite easy.

Client - Server Based Application in the Dyalog APL Environment

This paper is concerned with the problem of creating server-based application for the Dyalog APL environment on the example of "Agent". The "Agent" is a new common tool for the portfolio management system SOFIA® (product of APL Italiana®), and GAMA (product of Infostroy ). Briefly, "Agent" can be called as a "third arm of a customer" or an "extra user". This application executes the user-defined tasks in the system based on a specified schedule. The task is any operation (or a sequence of operations), which the user can produce in the portfolio management systems.

High Performance Computing through Parallel Processing

At the department for computer science of the Technical University of Berlin a workstation network based on Unix was established in the early Nineties as a substitute for the mainframe architecture.

In order to satisfy the demand for DOS/Windows a PC-network was also installed. Shortly thereafter, however, the demand for constant control and limitation of the users' space arose. Furthermore the task for administrators to manage large groups of users or several disks under the NT-Server became increasingly important.

As a member of the system administration group I got the job of testing the already existing programs as well as developing new ones for these purposes. At very first I had to learn that the Unix-command "du" (disk use) does unfortunately not exist on NT.

On the one hand, we started with a modified PERL-program that needed several hours to run. Nor was a DOS/REXX Program more successful in terms of satisfactory performance. On the other hand, I tried to solve the service tasks more rapidly by using a sequential APL2 program combined with AP 100. Finally, I achieved the best results with a parallely designed APL2 program which I will introduce below in "Documentation with some explanation".

What's Wrong with APL2

Design of a programming language is both an art and a science. A notation must be formally correct yet usable. Formal correctness is subject to rigorous analysis but usability is more difficult to measure. If there was only one correct formalism, language design would be easy - identify the correct notation, implement it, and use it. Unfortunately there are many correct notations and reasonable people may have differing opinions as to which is more usable. This paper will discuss some features of APL2 which, while not exactly wrong, might have been more useful had a different choice been made. Unfortunately this is quite a short paper.

Defining APL Community

I have been attending APL conferences for just under a quarter century now, and the one theme that runs through many conversations at all of them is how "APL is dying". Between conferences, I hear this time and time again, usually most loudly from people least qualified to know the truth of such remarks. In some organizations, this takes on the momentum of a self-fulfilling prophecy, usually promoted by those who have something to gain from ending the use of APL.

Object Oriented APL

The importance of Object-Oriented techniques is perhaps one of the most significant changes in programming over the last decade or more; in 1991, a team of three (Jacob Brickman, Michael J. Kent, and the author) began looking into what would be required to extend APL interpreters to provide native support for OO. At this writing, we have a great deal of agreement about overall architecture, some significant issues to resolve, an overall consensus that it is time to share these ideas, and we have also come a long way in learning what is required of APL interpreter developers. This effort has driven each of us into topics we might not have explored otherwise, and this knowledge has been used to good effect elsewhere. The purpose of this paper is not so much in providing exhaustive enumeration of the definitions we have agreed upon, but to introduce our architecture to interested parties, show that APL can be extended with OO in reasonable ways, and stimulate serious discussion of this topic among system developers and other APL implementers.

Interest Made Simple with Arrays

This paper presents a few ideas on how students might use J in the mathematics of finance. The emphasis is on using J as a calculator that has lots of memory and can store and compute with arrays. Therefore data will be entered and expressions evaluated but no programs will be presented in the classroom. (However, two utility programs and a few names for J primitives will be used as noted in the next subsection.)

APL Tutorial in Mathematical Modelling

The software presented below is a computer tutorial in mathematical modeling. The term "Mathematical Modeling" does not have a precise definition. We use the term to imply problem description in mathematical terms and the use of mathematical tools to investigate the given problem. For example, by using differential equations it is possible to describe a vast variety of different phenomena in the areas of physics, biology, sociology, etc. Some types of differential equations can be solved analytically, others require numerical methods and a computer. So today's mathematical modeler should be prepared to use a computer as an accessory.

The design and implementation of an APL dialect, ELI

ELI is an APL dialect that uses ASCII characters. It has a workspace based programming environment: all primitives of APL1[3] and control structures. It has no nested arrays or defined operators. Instead, it has user-defined data structures, and defined functions can take functions (in addition to variables) as parameters. ELI preserves the simplicity of APL1 while modestly extends it. The ELI interpreter is implemented on Windows using Visual C++, which connects to MFC to provide many GUI functions for the Window platform. The core interpreter consists of a parser, a tree-executor, and a module implementing all primitive functions. Currently the implementation also provides a function editor and the ability to save/load workspaces.

The Killer App

I've been a programmer for over 30 years, often at the leading edge, never in a classic IT shop. I've worked with several vendors' mainframes, midis and micros, for big firms, small firms, central government, educational establishments, and for myself; in colleges, universities, laboratories and classrooms; in England, in Europe, and in the USA. I've been involved in some total flops, but in one or two real successes too. I could never tell from the outset which it was going to be. The more I see of the software industry, the less I feel I know anything about it. Giving a talk like this is sticking my neck out.

But plus ça change... plus ça la même chose. I think I've seen enough by now, and maybe my experience will interest somebody. We've all dreamed of writing the APL program which will make our fortunes. I've had to launder my examples, to protect the guilty along with the innocent. But where I name names, what I have to say is already in the public domain. I've omitted a detailed reference - this will have to await the book. Most of the principles I've discerned I'm going to present as the experience of two fictitious companies, Company A, Company B.

Company A is not just based on one particular company I've known. Nor is Company B. I bought a honeycomb once. It said on the back 'Produce of more than one country'. I thought, what a marvellous thing - the dear little bees had actually co-operated in an International Honeycomb! A lesson to us all. But my fictitious companies really are a blend. Not an International Beehive. (Not even IBM was like that.)

Experiences with APL on a Mainframe as a WebServer

The first experiences with APL2 and TCP/IP in our firm, the ALLIANZ Insurance company, date back to the year 1994. We began to experiment with the connection of two APL2 sessions via TCP/IP under OS/2. At that time, TCP/IP began to emerge as a new industry standard on local area networks and our task was to connect two disparate applications over a network.

Representation of ASN.1 in APL nested structures

Abstract Syntax Notation One, or ASN.1, is a standardized data format for data networks and open system communications, defined by the ITU. Several TCP/IP protocols and security applications are based on it. In order to use APL to implement software solutions in this field, we need tools that allow us to manipulate data in ASN.1 format. This presentation gives an overview of the ASN.1 encoding and describes a mechanism for transforming complex ASN.1 contents into APL nested structures and vice versa. The handling of security certificates using Dyalog APL is also discussed. In fact, it would be possible to extend APL could convert any object, even a whole workspace, to ASN.1.

An Improved Method for Creating Dynamic Web Forms Using APL

The subject of this paper is "active" or "dynamic" web forms handled by Dyalog APL running on a web server. With "active" web forms, the HTML which specifies form controls is generated dynamically by a server program, in contrast to "static" web forms in which the HTML is fixed and does not vary from one page hit to the next. Also, I will be discussing only "thin client" approaches which minimize the amount of code which runs on the client machine. The method shown, which I call a "standard template" method, allows source pages to be maintained with visual tools such as Macromedia Dreamweaver and minimizes the amount of coding required when new forms are created in the same general format.

Dyalog-APL application with threads on the basis of ActiveX Data Objects

This paper presents an implementation of ActiveX Data Objects (ADO) in multithreading Dyalog-APL applications providing high performance access to any data source. The suggested approach is based upon an OLEClient object of Dyalog-APL that provides an OLE (Object Linking and Embedding) automation mechanism for working with ADO as an OLE Automation Server. This concept of such Dyalog-APL applications consists in a presentation of data-processing on 3 levels of hierarchy:

Communication between PC and Mainframe via TCP/IP using APL

There is a growing demand to be able to process data, maintained within large mainframe databases, using Windows based workstations, thus making communication between workstation and mainframe necessary. The availability of the APL language on both platforms simplifies this problem tremendously, and offers the potential to use almost identical code on both systems. The workspaces (for APL+WIN 3.0 and APL2 Mainframe) written by the authors, allow the user to run a stateless server on one platform, which can then process incoming requests from any platform using TCP/IP. (A host-to-host communication facility is not yet provided.) Several specific server commands let multiple users interact individually with the server, e.g. to combine GUI and mainframe data or to plot mainframe data directly using standard software products such as MS-EXCEL.

Avoiding the Pitfalls of Corporate Intranets

This paper describes some typical problems experienced in corporate intranets and introduces a way to use XML in order to overcome these problems.

A Dyalog APL implementation for intranet maintenance is used to illustrate how APL and XML work together.

Noun Phrase chunking with APL2

The identification of phrases in a sentence can be useful as a pre-processing step before attempting the full parsing. There is already much literature about finding simple non-recursive non-overlapping Noun Phrases. We have modified the learning paradigm CLOG [4] to produce transformation lists, and we arrived to several interesting conclusions about Noun Phrase chunking. IBM APL2 was used to build a prototype that was later rewritten in C++ for performance purposes.

Houses, Windows and DOHR's (Descriptive Objects of High Rank)

Anyone who buys a house can appreciate the complexity of a mortgage. Mortgage analysis requires not only significant computations, but also vast quantities of input and output. The interface between APL and Windows can provide a link between the input and the calculations; however, display of the output remains a problem. Mortgage data are inherently multi-dimensional, resulting in high-rank arrays. The dimensions involve individual mortgages or bond classes, and various prepayment and default scenarios, time periods, and cash flows.

Although higher rank arrays can be difficult to visualize and interpret, a matrix can be displayed quite easily as an HTML table with row and column headers identifying the data. In a GUI, it can be displayed as a grid object. A rank-3 array can be displayed as a series of HTML tables each linked from a table of contents at the beginning of the document; as a GUI, it can be displayed as a tab control, each tab containing a grid object.

APL has many functions to handle high-rank arrays, e.g. dyadic transpose, indexing, and the reduction operator. Descriptive Objects of High Rank (DOHR's) are nested arrays containing built-in captions, named axes, and named indexes. Certain fundamental operations can be performed on these objects to produce easily readable output. These include selection, summary, orientation and annexation. These fundamental operations are based on upon the following APL concepts: reduction--the removal of an axis, compression--the removal of one or more indexes, transpose--the rearrangement of axes, and catenation/lamination--combining objects along an axis. Most functions that apply to DOHR's can be built upon these fundamental operations.

SPARROW - a speech- and knowledge-based architecture for a workplace

An architecture is presented, which for complex office-systems makes use of speech-processing as well as various methods from artificial intelligence in order to increase the acceptance of such systems. Support can only be useful, if it is twofold: the end-user has to be supported in his daily tasks, but the ADE (application development engineer) also needs a tool to support him in the difficult task of configuring a work-place system and keeping it up to date, since the requirements on his qualifications span a wide area.

GrAPL - A High-level Statistical Graphics Language Prototype

The work of statisticians and data analysts requires the fitting of a wide range of statistical models that attempt to explore relationships between variables. Before doing these computations, it is routine to produce exploratory graphs in order to discover these relationships. After model fitting, again graphical tools are required in order to explore how satisfactory the model fitting process has been. It is therefore really important for the statistician to be able to produce a wide range of graphs easily and quickly.

GrAPL is a prototype language for this purpose; it uses Adrian Smith's RainPro as a graphics engine and attempts to incorporate some of the latest statistical graphical tools that are available in modern statistical packages within a coherent graphical language. APL is used as a 'tool of thought' to encourage experimentation within a short development period.

High-level Object Oriented Programming with Array Technology

Although classical object-oriented programming languages provide high-level modeling capacities (abstract data type, inheritance etc.), they remain low-level relative to data manipulation. Addressing this problem with object oriented programming languages is an important mission of today's research. Considerable work has already been done, leading to the development of tools such as object query languages, with mixed results. In this paper, we present the key points of a new approach to this problem. We propose an enhancement of object oriented programming at the core level, by integrating Array Programming, a high-level model for computing. Our solution is based on an extension to object oriented programming. This integration of object technology and Array Programming allows for high-level object-oriented programming. At the same time, it opens Array Programming to the powerful world of objects.

APL Based Medical Image Analysis

Ophthalmology (eye care) is an important medical discipline. Since 1961 the representation of the ocular vascular system using fluorescence dyes has been one of the most important methods used in the diagnosis of diseases of the human eye. The recently introduced laser scanning systems allows fast and continuous imaging of the complete inflow of dye into the vascular system. With the aid of APL as a well-suited image analysis tool it is now possible to analyze these image sequences to extract diagnostic relevant blood flow parameters. During the image acquisition there are unavoidable eye movements which render the automatic follow up of a specific area over time more difficult. Therefore a method has been developed to robustly analyze the eye movements. Beside the determination of the filling delay, i.e. the time of dye appearance for every point, the filling time has been measured. Result images will be presented for two different cases. A slightly modified algorithm is able to automatically compose a panoramic wide-angle retinal image out of partially overlapping single images. The APL system itself (called APL2C) and the algorithms for the image processing have been developed by the author and are not commercially available.

An APL Compiler

Even if APL is the best-suited programming language for multi-dimensional data, nowadays computer applications additionally require complex graphical user interfaces, internet and database access. Combining software written in C, C++ or Java with interpreted APL programs is difficult. A homogeneous solution has been found by automatically converting APL programs into native C code. A complete APL2 like system including interpreter and session manager has been implemented in ISO C from scratch based on the standard C library. It is the property of the author and not yet commercially available. It has been successfully compiled on several operating systems. The built in system call ?APL2C allows one to compile any APL function including all referenced functions or operators within the workspace into native C code and completely removes the interpreter using direct calls to the C coded APL primitives. Only obvious restrictions (no runtime execution of character arrays or dynamic creation of functions via ?FX) apply. In addition, a makefile is created to enable the simple build of standalone executable files. The C files, generated by ?APL2C, can be easily mixed with other C/C++ source files and compiled on any platform provided that the required library for the APL primitives is available.

An Integrated APL2 Solution for Population Screening and Control

When dealing with preventive medicine involving entire population strata, the wide class of problems encountered requires powerful and highly sophisticated data management support tools. In this paper an example is given of how APL2 offers an ideal solution for such complex situations: data acquisition, preprocessing and filtering; real time connections with local and remote relational date base; use of any type of statistical and optimization model for decision support. Furthermore this efficiency is available using the standard graphics interface of Unix, Warp, Windows 95 or NT environments, whichever the user choice may be.

The present application uses APL2/2 and DB2/2, available under OS/2 at a district level and APL2/6000 and DB2/6000 for a central coordination at a regional level. Besides the standard type of text information and data processing, the application is open to any kind of image acquisition and retrieval, as well as any advanced mathematical model on population behavior and dynamics.

Gerva: Secure Electronic Legal Communication with Attributes

The main cause why we developed in APL is that we want to make communication with emails secure. This is especially important for our users who are tax consultants or lawyers. They need encryption in order to able to send sensible data via the internet.

Additionally they need digital signature in order to be sure who send them an document and that the document has not been changed.

One special feature of our application is that we use digital certificates which contain the attribute of the person. So you can see whether the person is an lawyer or an tax consultant or something else. In order to get an attribute in the certificate the responsible professional association has to confirm that.

Reason to take DyalogAPL: you are able to design software in with less amount of time (rapid development), you can easy handle variable data structures (ASN.1, X.509 certificates) and also have a comfortable GUI.

A Knowledge Discovery Method -- APL Implementation and Application

The paper concentrates on one direction of Knowledge Discovery in Data Bases and Data Mining, known as automatic rule extraction from data sets.

The rule extraction algorithm has been implemented in Dyalog APL. The paper presents APL functions and tests made on artificial data sets.

The real life problem solution is described as an application of implemented APL code. The problem is to find automatically rules to describe the corrosion rate of steel in sodium as a function of alloy additions. The input data are experimental data of corrosion rate measured for different steel samples. The output is a set of IF-THEN rules, which describe the dependence of corrosion rate on alloy additions. An expert in corrosion has validated the rules and an example of real "discovery" has been mentioned.

Redistribution of Totals Through Hierarchical Data -- An Application of Benkard's Distributed Round

The early days of APL are full of examples of spreadsheet-style applications which allow the user to maintain aggregated values and quickly redistribute the changes across base data. Generally these use a simple pro-rata approach which always leads to rounding problems where the adjusted values no longer sum to the required total.

The example discussed in this paper was developed for the Strategic Planning manager at Nestlé-Rowntree and a key requirement was to permit rebalancing of adjusted totals throughout an arbitrarily deep tree-structure. In this case a simple pro-rata leads to endless imbalances, and the trick is to use Benkard's distributed rounding which ensures that when changes to aggregates are redistributed, the detail always adds exactly to the required total.

The concept is illustrated using the VideoSoft Flexgrid OCX control. The Flexgrid was used here because it has a very simple and powerful approach to managing gridded data where one of the dimensions has an outline structure.

Spoken-Word Direction of Computer Program Synthesis

Prototype software is being designed to orchestrate speech-directed synthesis of customizable computer programs. The problems encountered are considered from a perspective that assumes the notation, syntax and function structure of APL. Program synthesis is to be completed with spoken-word dialogs between humans and computers. The computer is to assist in constructing programs with minimal or zero need for mechanical contact between mobile users and computer hardware. During synthesis, the system is to respond audibly and, only when necessary, visually. Spoken commands that invoke functions must be easily recognized in a limited vocabulary in a given context for interactively completing specification of each program. Experimentation with prototype system is expected to facilitate the replacement of conventional text-entry programming systems by that a practical one for speech-directed program synthesis and development.

An Interface Between Java and APL

This paper discusses an interface between the Java and APL languages. It is in the form of a report on some technology that has been developed for SHARP APL, though there are no aspects of the technology that are particularly special to that dialect of APL.

The interface (called, for the purposes of this paper, the "APL-Java Interface") is a general facility for allowing APL programs and Java programs to work together. The project was started because it occurred to us that there is now a substantial body of Java-based technology that solves many of the problems that we needed to address for APL, particularly in the area of program interoperability; and, since this Java-based technology is both widely (and, in many cases, freely) available, and portable across the platforms that are of most concern to us, it would make a lot of sense to try to develop a general way to access this technology from APL. If that could be done, we could largely avoid re-inventing the wheel in a whole set of instances, by capitalizing on existing Java-based solutions. As a simple example, rather than implementing the standard XML parser in APL (which is certainly possible), we could simply use one of the several existing Java implementations.

Comparative File I/O Methods in APL2

This paper will discuss the state of file I/O in APL2. The intent is to educate the readers on the options open to them so that they can choose the file I/O method most suitable for their needs.

Topics will include evolution of file I/O over the years, current status on a platform-by-platform basis, mainframe to workstation migration issues, suitability of the different methods available for various tasks, and performance notes.

Visual Representation of Document-Oriented Information on the Web

Ever increasing volumes of data motivate us to find new processing and storage methods for provide quick retrieval of information. Users of conventional text-based search engines have faced the problem of digging through thousands of hits returned from keyword searches. There are alternative ways of storing and searching document-related data; these techniques support more direct and simplified document searches guiding the user towards fewer but higher quality selections.

One such method is known as WebSOM, Web Self-Organizing Maps, which are based on Kohonen's neural network approach and modern graphical user interfaces. We will show, through the use of APL with this and other methods of information analysis, how to visualize this type of search.

Making of a Conference: APL92, St.Petersburg, Russia

An Array Based Simulation Approach for Predicting the Impact of Different Measles Vaccination Strategies in Lower Saxony

Based on measles case data from pediatricians in Lower Saxony, a simulation study was conducted in order to reproduce the current vaccination­disease relationship and afterwards predict the impact of different vaccination strategies. The programs were written in S­Plus and make use of the language's array processing facilities. The process of infection was modeled by means of an age­structured compartmental model. The main data structure is a two dimensional array, representing the complete population, partitioned according to age cohorts and the compartments, which represent the stages of infection. The flow of individuals through the compartments is modeled weekly and performed by means of array operations. The number of new infections in each age cohort is simulated as a Poisson random variable, depending on the number of infectious individuals of any age and the transmission probability between ages. The transmission coefficients are organized in a matrix enabling the transmission process to be computed by matrix multiplication.

Graph Notation for Arrays

A graph-theoretical notation for array concatenation represents arrays as bubbles with arms sticking out, each arm with a specified number of "fingers". Bubbles with one arm are vectors, with two arms matrices, etc. Arrays can only hold hands, i.e., "contract" along a given pair of arms, if the arms have the same number of fingers. There are three array concatenations: outer product, contraction, and direct sum. Special arrays are the unit vectors and the diagonal array, which is the branching point of several arms. Outer products and contractions are independent of the order in which they are performed and distributive with respect to the direct sum. Examples are given where this notation clarifies mathematical proofs.

Handling Context­Sensitive Syntactic Issues in the Design of a Front­end for a MATLAB Compiler

In recent times, the MATLAB language has emerged as a popular alternative for programming in diverse application domains such as signal processing and meteorology. The language has a powerful array syntax with a large set of pre­defined operators and functions that operate on arrays or array sections, making it an ideal candidate for applications involving substantial array­based processing.

Yet, for all the programming convenience that the language offers, designing a parser and scanner capable of mimicking the language's syntax has proven to be an acutely difficult task. The language has many context­sensitive constructions, and though numerous front­end implementations of MATLAB and MATLAB­like languages exist, not much has been discussed regarding the efficient compile­time parsing of such languages or how its syntax impacts the parsing process.

In this paper, we present the design and implementation of a compiler front­end for the MATLAB language. We discuss in detail both the indigenously designed grammar responsible for syntax analysis as well as the lexical specification that complements the grammar. In the course of our attempts to emulate MATLAB's syntax, we were able to unravel certain key issues relating to its syntax, such as the complications arising in parsing command­form function invocations within a compile­time environment, the context­sensitive interpretation of the single quote character, and the translation of white space within matrices into element separators.

The front­end effects a conversion of the original source to an intermediate form in which statements are represented as abstract syntax trees and the flow of control between statements by a control­flow graph. All subsequent compiler passes work on this intermediate representation.

The front­end was designed and implemented as part of the MATCH project, which addresses the translation of a MATLAB program by a compiler onto a heterogeneous target consisting of embedded and commercial­off­the­shelf processors.

A symmetry­based formalism for array subtyping

This paper presents an array algebra based on the concept of symmetry. The symmetries taken into account are translational, affine and polyhedral symmetry as well as the access symmetry inherent in distributed arrays. The full set of data­parallel array operations is represented in terms of four fundamental skeletons: Map, Juxtapose, Select, and Concatenate; which are strongly typed and overloaded for all combinations of operand symmetries. A hierarchy of three further skeletons are used as parameters to Map in order to express reductions: commutative­associative, associative but not commutative, and neither associative nor commutative. Any user­defined part of the computation is represented in the form of scalar functions as skeleton parameters, without any loss of generality. Successful type inference in the presence of subtyping is enabled by a homomorphism restriction imposed on all overloadings of the skeletons. As a result, we are able to infer the most symmetric type of any well­formed term, which is usually the cheapest one to compute.