bluuebunny/crossref_metadata_2025 huggingface dataset:
On providing useful information for analyzing and tuning applications
Authors: Mellor-Crummey John , Fowler Robert , Whalley David
Published: January 2007

Application performance tuning is a complex process that requires correlating many types of information with source code to locate and analyze performance problems bottle-necks. Existing performance tools don't adequately support this process in one or more dimensions. We describe two performance tools,
MHsim
and
HPCView
, that we built to support our own work on data layout and optimizing compilers. Both tools report their results in scope-hierarchy views of the corresponding source code and produce their output as HTML databases that can be analyzed portably and collaboratively using a commodity browser.
Alternative techniques for the efficient acquisition of haptic data
Authors: Shahabi Cyrus , Kolahdouzan Mohammad R. , Barish Greg , Zimmermann Roger , Yao Didi , Fu Kun , Zhang Lingling
Published: January 2007

Immersive environments are those that surround users in an artificial world. These environments consist of a composition of various types of immersidata: unique data types that are combined to render a virtual experience. Acquisition, for storage and future querying, of information describing sessions in these environments is challenging because of the real-time demands and sizeable amounts of data to be managed. In this paper, we summarize a comparison of techniques for achieving the efficient acquisition of one type of immersidata, the haptic data type, which describes the movement, rotation, and force associated with user-directed objects in an immersive environment. In addition to describing a general process for real-time sampling and recording of this type of data, we propose three distinct sampling strategies: fixed, grouped, and adaptive. We conducted several experiments with a real haptic device and found that there are tradeoffs between the accuracy, efficiency, and complexity of implementation for each of the proposed techniques. While it is possible to use any of these approaches for real-time haptic data acquisition, we found that an adaptive sampling strategy provided the most efficiency without significant loss in accuracy. As immersive environments become more complex and contain more haptic sensors, techniques such as adaptive sampling can be useful for improving scalability of real-time data acquisition.
A microcoded multiprocessor crossbar network communications controller
Authors: Hall Clifford L.
Published: January 2007

This paper describes the architecture and microcode organization of an Interprocessor Communications Controller (ICC) for a multi-microcomputer system employing a fully parallel crossbar switch. The communications controller provides fast data transmission between seven microcomputers via nonvectored interrupts. Also, within the communications controller, programmable 16-bit down-counting timers are available to each of the microcomputers within the multi-microcomputer system.
MASCO
Authors: Fenner Jack N. , Schmidt Jeffery A. , Halabi Houssam A. , Agrawal Dharma P.
Published: January 2007

The design of a host machine architecture for implementing an existing image machine architecture is considered. The proposed microarchitecture uses a microprogrammed control unit to emulate the Motorola MC6809 microprocessor architecture.

The detailed hardware characteristics of the proposed machine are described and the microinstruction set is defined. The microroutines that emulate the MC6809 instruction set have been developed. A practical implementation using current technology is studied and some realistic timing characteristics are determined. The simulation of the proposed architecture is reviewed and the performance is evaluated. Finally, comparisons with existing models are made and the results are discussed.
Design verification of a VLSI VAX microcomputer
Authors: Samudrala Sridhar , Lo Charles , Brown John F. , Calcagni Richard E.
Published: January 2007

Design verification as part of development provides an opportunity to correct design errors, improve performance characteristics, and optimize hardware. This paper presents the strategy and an overview of the verification performed in the development of a VLSI VAX microcomputer. Using a hierarchical methodology for simulation and verification, the logic design and circuit design have been verified.
The implementation of the attributed recursive descent architecture in VAX-11/780 microcode
Authors: Ardoin C. D. , Linn J. L. , Reynolds B. W.
Published: January 2007

This paper describes a case study in the implementation of a special purpose architecture on a particular microprogrammable engine. The host engine used is the VAX-11/780; the target architecture is one tailored for implementing recursive descent translators. The paper describes the mapping of the target resources onto the host machine including a discussion of the issues involved in interfacing with the normal VAX environment. The architecture specification does not mandate the exact bit-level representation of the target architecture instructions allowing a more efficient emulator to be constructed. Many of the important design decisions involve choosing instruction representations to effectively utilize the host engine. The paper concludes with discussion of the considerable shortcomings of this approach, of the suitability of the VAX-11/780 as an underlying engine for the target architecture, and of the implications of the study for universal host machines.
Alternative proposals for implementing Prolog concurrently and implications regarding their respective microarchitectures
Authors: Ponder Carl G. , Patt Yale N.
Published: January 2007

Prolog has become a subject of much discussion of late. It has been suggested as the logical language for programming expert systems. A parallel variant is said to be the language of the Japanese 5th Generation Project. In this paper the standard Prolog language is defined and shown to be a restriction of Logic Programming. Several alternative schemes, which have been proposed for improving the performance of Prolog, are examined. Some schemes change the semantics of the language; these effects are discussed. All schemes have implications on the microarchitecture of the implementing engine; these implications are studied.
Sequential Prolog machine
Authors: Tick Evan
Published: January 2007

A modified version of D. Warren's sequential Prolog machine architecture is described. Data and instruction formats are given. A microcoded host architecture is also described, with formats and examples presented.
A new universal microprogram converter
Authors: Takahashi Kazutoshi , Takahashi Etsuo , Bitoh Tatsushige , Sugimoto Takao
Published: January 2007

Following the software crisis, a firmware crisis has occurred.

Since too much man-power and time is needed to develop microprograms, the ones already produced like software have to be used as long as possible.

This paper describes a general purpose microprogram conversion tool which is one of the methods used to reduce the man-power and time required for microprogram development and examples of the execution results obtained using this tool.
Global methods in the flow graph approach to retargetable microcode generation
Authors: Mueller Robert A. , Varghese Joseph , Allan Vicki H.
Published: January 2007

We have reported on
local
retargetable microcode generation methods based on the
flow graph model
in previous papers. In this paper, we consider the extension of these methods to
global
retargetable microcode generation. This includes intermediate representations of basic blocks containing control flow directives and their construction from global program dags, resource allocation and its interaction with code generation, machine-independent semantics and procedures for global microcode generation, and global compaction. The emphasis is on issues and promising directions for research on global methods
vis a vis
final results and definitive answers, as it reflects the early stages of our research.
Logic programming applied to hardware design specification and verification
Authors: Sidhu Deepinder P.
Published: January 2007

This paper proposes the use of logic programming techniques in the specification and verification of hardware designs. Logic programming specifications are formal and directly executable. The advantages of executable specifications are: (1) the specification is itself a prototype of the specified system, (2) incremental development of specifications is possible, (3) behavior exhibited by the specification when executed can be used to check conformity of the specification with requirements. We discuss how Horn clause logic, which has a procedural interpretation, and predicate logic programming language, Prolog, can be used as a hardware description language to specify and verify the correctness of hardware systems. The Prolog system possesses a backtracking mechanism and a powerful pattern-matching feature which is based on unification. A novel feature of the proposed approach is that it can be used to answer interesting questions about a hardware design without resorting to simulation.
Practical uses of operators in Sharp APL/HP
Authors: Hodgkinson Robert
Published: January 2007

At APL86 in Manchester, the language features of SHARP APL/HP on a Hewlett Packard range of minicomputers were introduced in a paper written by this author, entitled 'APL PROCEDURES (USER DEFINED OPERATORS, FUNCTIONS AND TOKEN STRINGS)'. This is the first of several papers which have been planned to supplement this introductory work. The models of several new and existing operators are described in detail, all of which may be directly executed in SHARP APL/HP. The models take advantage of various features of SHARP APL/HP including extended assignment and procedure arrays [1] (often referred to as function arrays in their most common form). The paper will pursue a comparison of the less general implementation of operators in APL2, with special reference to Ed Eusebi's pioneering work in the field of 'Operators for Program Control and Recursion' [2 3], wherein an alternative definition for several of these operators will be proposed. The paper will then proceed to describe 'Operators applying to Enclosed Arrays' (for example a Pervasive Operator) and various 'Mathematical Operators' (instances of which are the Power and Transitive Closure operators), always highlighting these models with examples of their practical application.
Why APL2: a discussion of design principles
Authors: Brown James A.
Published: January 2007

APL
2 represents a quantum leap in the function of the
APL
notation over earlier IBM offerings. Achieving a consistent language required going back to the fundamentals and rethinking some of the original principles of
APL
and in a few cases making some changes.

This paper discusses some of the extensions and gives the reasons why they were chosen over other possible extensions.
Programming considerations for documentation and maintenance
Authors: Fleming Stephen C.
Published: January 2007

The intent of this paper is to create, or reinforce among programmers an awareness of some simple measures which can be taken during application system development, which can save valuable time later, when somebody else is called upon to document, fix, enhance, or otherwise read and work with their programs.

Although the paper describes several approaches to system documentation, it is not expected that any programmer will henceforth develop his applications exclusively around and according to the needs of the technical writer or maintenance analyst. The hope is that by describing a broad range of techniques, individual programmers can select those which best suit their style and approach, while minimizing the imposition of rigid and burdensome “standards”. The premise being that some, any, assistance provided to future readers, is better than none.
A model for teaching APL: moving into the fast lane
Authors: Traberman Tama
Published: January 2007

The business world is in the throes of an on-going revolution. In today's global business environment, managers must be smarter than the competition if they want to increase their market share and provide customers with new services and products that capture the imagination and new customer dollars. All stock brokers and investment bankers want to maximize their clients' investments. Yet some firms consistently are more successful than others in choosing the right investments for clients and at attracting new clients. Some retail chains go out of business while others flourish. What differentiates success and failure?

Smart managers in this ever-changing global market are discovering that APL and APL tools can give them a competitive edge. APL is a strategic tool that helps their staff members be more efficient, more effective and more creative on the job. And while it is true that people can learn APL on their own, good managers recognize that it is more efficient for employees to get professional instruction in APL. These managers recognize that their employees want to learn APL quickly. They want to learn the most current usage of the language in the context of the business applications they use on the job. Knowledgeable professionals want and need professional instruction that matches their job skills and competencies in order to accelerate the slope of their APL learning curve.
An object oriented extension to APL
Authors: Girardot Jean Jacques , Sako Sega
Published: January 2007

This paper describes an object oriented extension of APL, which is currently being implemented in a new APL system. This extension is integrated in a rather conservative way to APL. However, all the paradigms of object oriented languages (message passing, instance variables, methods, classes and inheritance) are made available to the user, without losing any of the successful features of APL.

The paper first explains what are the interests of object oriented programming, and what is expected from this introduction in the language. It then discusses syntactic and semantic choices, and shows how the selected solutions fit the philosophy of APL.

An example of this new style of programming in APL is proposed, then the internals of the implementation are presented, showing that this new possibility is made available at the cost of a minimal system overhead. Finally, the paper discusses about the results obtained so far.
Implementation of an APL—based spreadsheet manager
Authors: Puckett Tom
Published: January 2007

This paper describes the implementation of the STSC Spreadsheet Manager for users of STSC's APL*PLUS® PC System. The discussion is primarily from the standpoint of the product's internal workings. Important aspects are selection and interfacing of the languages to be used in the implementation (APL, C, and assembler), compatibility with Lotus® data structures, mappings between data in the APL and Lotus environments, manipulation of data in a spreadsheet context, and separation of function between APL and C environments.
Server networks communicating via inter-user shared variables
Authors: Zeidner Lawrence
Published: January 2007

Server networks are generalized networks of asynchronous software processes interconnected by prescribed communication links according to prescribed protocols. As large-system-integration tools, they facilitate a divide-and-conquer approach, separating large software system development problems into a set of smaller problems programmed-in-the-small via standard software techniques within the confines of each server's virtual machine. In addition, server networks, programmed-in-the-large, knit together the solutions to these smaller problems. This paper presents the concepts of a server-network methodology that includes inter-server communication, the provision of and subscription to utility services, and the data-driven control-flow (DDCF) of server networks, which makes the remote dynamic reconfiguration of server networks possible through graphical programming. A server-network generator (SNG), which is an expert system that facilitates the graphical configuration, modification, and archival of server networks, is presented. Our APL2 implementation of server networks, including the implementation of utility services as generic building blocks, is described. Enhancements to the APL2 system services, which would benefit the future of server-network research and its application to production system management through horizontal integration of the factory floor and cooperative processing among networks of mainframes and engineering workstations running the VM/370 operating system, are presented.
APL extensions—a users view
Authors: Jordan Maurice H.
Published: January 2007

There has been much heated argument about extensions in APL. This paper reflects 5 years' experience with one brand of extensions (STSC's nested array system). Useful and irritating features are discussed.

Facilities available are compared with other implementations - APL2, Dyalog, and IPSA. Topics covered include event handling, file systems, strand notation, indexing, the each dual and rank operators, and interfaces to other languages. The paper is illustrated with examples drawn from code produced internally, and from VECTOR competitions.
APL function definition notation
Authors: Bunda John
Published: January 2007

A pure functional notation for defining APL objects is described, and constructed with previous work in this area. The notation is extended to address both theoretical and pragmatic programming considerations. The notation is compatible with existing implementations, and is shown to straightforwardly incorporate popular extensions to the language.
A CAD system in APL
Authors: Gujar Uday G. , So Joseph W. P.
Published: January 2007

A two-dimensional Computer Aided DEsign Tutorial System (CADETS) has been designed and implemented and is reported in this paper. The graphics screen is divided into five windows. The main, and the largest, window is used for graphics; the others are used for user communication which is achieved through a structure of well defined menus and the system messages. There are currently eleven ways to create a point, thirteen ways to create a line segment, ten ways to specify a circular arc, several functions to generate common geometric objects such as triangles, rectangles, polygons, conics and ten fonts to write labels. Once created, the user may pick the geometric entities in the current model for inquiry, transformation or deletion through a series of selection menus. Translation, scaling, rotation, and mirroring is facilitated by transformation functions. Model file management functions enable the user to store the created geometric models on an auxiliary device and retrieve and manipulate them with options to move, copy or duplicate the transformed entities. The power of CADETS is further enhanced by the introduction of layers. This facility enables the user to view and draw each individual layer independently or to view selected layers simultaneously.
TSIOPAK—a proposal for a new Sharp APL file system
Authors: Leon Carlos G.
Published: January 2007

Communication between OS files is often necessary when information that is manipulated and stored in Sharp APL files is required to be used by non-APL routines. For example, one may use APL for number crunching and have the output processed by SAS or FORTRAN to plot the data.

The arising demand for procedures that would make data accessible from APL to other systems motivated the author to take action.

TSIOPAK was developed with the intention to provide a standard interface between Sharp APL and the MVS operating system facilitating the accessibility of data created through APL and other languages. In addition, the reader will find that starting from the section titled the TSIOPAK File System, the format for each section looks very much like the Sharp APL Reference Manual. This is not a coincidence, what the author has tried to achieve with this work is to have a file system functionally identical to Sharp's using OS files. The author's efforts have gone as far as trying to replicate the format of Sharp's manual.

In addition, parts of the Sharp APL File System have not been implemented in TSIOPAK due to the lack of time and resources. Hence, this paper is a proposal for a new file system which would make APL-generated data generally available.
Implications of APL2 grammar
Authors: Benkard J. Philip
Published: January 2007

A subtle but pervasive feature of APL2 is its new way of describing syntax. It is based on an ordered list of ordered pairs of syntactic classes. Position in the list corresponds to the strength of the syntactic bond between objects of the classes in the pair. The single rule of execution is to scan from the right until the binding drops and then evaluate the pair of objects just scanned.

The new simple view of syntax suggests some straightforward extensions to the language which do not complicate the syntax and address such areas as:

specifying a variable number of iterations of EACH in a manner analogous to the way a power operator can specify iterations of a function.

using similar and similarly simple expressions to apply structural functions and operators, for example (2 3 ↑)″ A B C and (2 3 /)″ A B C require, respectively, that the named objects be of rank 2 and of length 2 (after scalar extension). The first expression is, of course, not valid today; the second is, and the parentheses are redundant.

creating arrays of objects other than data, a subject treated in several papers in recent years

a number of identities involving functions and operators, including some which provide compact notation for concepts of elementary arithmetic.

the elevators of Landaeta, which are only possible if a language contains identically structured expressions for objects of different symbolic classes, provide a way of describing analogues of an operation in different syntactic classes. These lead to an interesting new diagrammatic way of expressing identities.
Functional programming, the IEEE floating point standard and APL
Authors: Reed Terence J.
Published: January 2007

The IEEE standard for floating point numbers is by now reasonably well known, but less well known is the fact that this standard provides for a certain exceptional class of bit patterns, the use of which are left to the user. In this paper we explore uses for this class among which are provisions for a variety of infinities and a flag for undefined entities. It is proposed that the functional programming aspect of APL be strengthened by the provision of void returns as provided in a few other languages such as LISP. At the programming level we explore methods for providing within APL near functional programming capabilities.
An APL idiom inventory
Authors: Peell Howard A.
Published: January 2007

An instrument is proposed for rating APL idioms. Scales include: Length □IO Independence Usefulness Efficiency Generality Clarity Simplicity Memorability Interestingness Elegance

This APL Idiom Inventory was pilot-tested by APL programmers and APL instructors who rated a dozen selected APL idioms. The results indicate which idioms they think are “useful”, “easy to learn”, “hard to remember”, “interesting”, etc. Implications for teaching and related issues are also discussed.
Infinite loops and how to create them
Authors: Searle John R.
Published: January 2007

Infinite loops are the worst enemy of any programmer in any language. They waste potentially huge amounts of time, system resources and/or money, and can destroy the credibility of the programmer amongst colleagues or customers.

In APL, infinite loops can potentially occur wherever a loop is present. However, they can also occur wherever any branching statement is used, and can even occur where no branching instructions have been used. In order to avoid infinite loops, the programmer is best equipped if he/she is aware of all of the possible ways in which they may be created.

An APL function is also presented which will give programmers new to the language a means whereby most infinite loops can be avoided in their training phase.
A proposal for blocks and exits in APL
Authors: Fiegenschue Jim P.
Published: January 2007

A simple method of expressing structured programming constructs is proposed which avoids the need for the large number of keywords found in most structured languages. With this simple method, a countably infinite series of constructs may be formed. It is demonstrated that all conventional structured programming constructs may be expressed using only the constructs corresponding to -1, 0, 1, and 2.
How graphics could be simplified in APL
Authors: Langlet Gerard A.
Published: January 2007

With the help of a new scalar primitive, named “Associate”, and, optionally, after introducing a notation for “unknown values”, this paper shows on some simple examples, how the combination of these new features with some existing primitives can enhance the capabilities of the language, especially in the field of graphics. Other facilities also result from these extensions, answering some fundamental questions about APL in general.
The syntax of APL, an old approach revisited
Authors: Girardot Jean Jacques , Rollin Florence
Published: January 2007

Most efforts have been made in the past APL conferences to propose new approaches to the analysis of APL, and introduce new features in the language. However, most of these proposals take very little in account the amount of work that has been made around syntax analysis in the 'main stream' of computer science.

The proposed approach, as described in this paper, can therefore be considered as an old work. We first describe the fundamental syntactic devices of APL. Those devices are then arranged as a standard BNF. We can exhibit some properties of the language described, and consequently select from the literature an appropriate technique to perform the syntax analysis of APL expressions. The proposed method uses a push-down automaton. Although the language is shown to be not LR(k), an adaptation of this technique works well using backtracking.

The whole process has been modelled in APL. A first application transforms a grammar expressed as a BNF in a set of tables. A second application uses these tables to perform the syntax analysis of APL statements. These last programs have been rewritten in C, integrated in an APL system, and used to test different dialects of APL, such as ISO-APL or APL2. Results show the influence of the cost of syntax analysis in the processing of APL expressions.
APL—compilation-where does the time come from?
Authors: Driscoll Graham C. , Orth Donald L.
Published: January 2007

We have developed an experimental system to compile APL by translating it into a high-level language that has a compiler. The compiled functions can be called by the IBM APL2 interpreter through its name-association interface. Five of the ways in which use of our system saves execution time are discussed here. For scalar APL code, some savings result from the removal of all parsing and much checking for conformability and case at run time. Substantial savings sometimes arise from the feasibility of searching for a wider variety of special cases. Where they apply, such complications as non-zero comparison tolerances are costly; we avoid these costs and expect the programmer to take care of these complications explicitly at the relatively few points where they are needed. By combining loops where possible, we sometimes achieve significant savings. Finally, we conjecture that the greatest savings are most often due to our general method of combining primitive APL operations; we can often eliminate redundant computation and avoid storing and fetching temporary results. Examples are given.
Using other languages to supplement APL
Authors: Soule Donald W.
Published: January 2007

This paper documents the struggles and successes of one of the development efforts of our company over the past 4 years -- supplementing APL application development with integrated C and Assembly modules on the PC. It deals with an area we have used multiple languages in -- integrating an Assembly and C screen handler into our APL application development.
Editing APL objects with CMS XEDIT
Authors: Brenner Norman
Published: January 2007

The VM/SP System Editor XEDIT is used to edit APL objects. Two approaches are possible: with an APL function, or with an exec written in REXX (the new VM/SP System Interpreter). The advantages of the latter are that nothing need be copied into the user's workspace, and that APL code can be executed from XEDIT, and XEDIT commands from APL. No new Auxiliary Processor is needed. The technique is in use at IBM Yorktown.
VLSI circuit design using APL with fortran subroutines
Authors: Brenner Norman
Published: January 2007

Our group at IBM Yorktown Research has written a number of tool programs for VLSI design, all in APL. Several crucial algorithms were speeded up by recoding them in Fortran and Assembler Language. For example, the algorithm for complementation of a Boolean expression (which can sometimes have thousands of terms in dozens of variables) is 5 times faster in Fortran than the best APL code I could write. The linking mechanism used from APL to outside languages is the experimental AP403 from IBM Heidelberg, though other similar auxiliary processors exist (e.g. the IUP AP999). Thus, each language, Fortran and APL, is used to its best advantage: Fortran for raw speed, and APL for interactiveness and ease of coding.
APL iconics
Authors: Dell'Oca Maurizio S. , Mussio Piero
Published: January 2007

The discipline of iconics refers to the integrated analysis, generation and management of digital images by computer. In pictorial data analysis, iconic techniques help a proper definition and design of interactive systems for the interpretation of digital images. The use of APL allows on the other side, the formal definition and the person-person communication of the designed tools, the quick and economic development of user-oriented prototypes and their tests and checks.
A high-performance environment for APL
Authors: Delo John , Friedman Sanford
Published: January 2007

Array processors are well known for their ability to process large amounts of array-oriented data at extremely high speeds for critical applications in the medical, scientific, and industrial sectors. As hardware costs steadily decline and as computer technology rapidly penetrates the business and financial arenas, the speed and capacity of array processors are evoking new interest among general purpose users. The problem, however, has been the array processor's extremely complex programming requirements, traditionally the province of engineers. APL provides a solution to the problem of moving array processors into less technical areas. By supplying the necessary hardware and software support to the array processor, Analogic has created a powerful environment that is ideal for APL. This paper discusses in detail those hardware and software systems that support the APL environment and enhance performance.
APL transmission path analysis for design of a local area network
Authors: Friedrich A. A. , Love R. D.
Published: January 2007

A method of analyzing the transmission capabilities and limitations of a Local Area Network communications channel is presented. A description is given of how APL was used to generate the eye patterns used to evaluate cable, transformer, and filter effects on the transmitted signal. These eye patterns were used to make design decisions regarding the network, and for generating the parametric data for another APL program package which calculates the length of cable permissible for a given configuration. This second package which evaluates signal attenuation and crosstalk resulting from each length of cable and each node, is used to synthesize valid configurations. A design example is presented.
Representation & combination of Boolean functions using APL
Authors: Gullichsen Eric
Published: January 2007

An ability to compactly represent and efficiently manipulate and combine Boolean functions is required in many tasks pertaining to digital logic design, including those of fault detection and isolation and the decomposition of switching networks. An APL implementation of Roth's cube array representation of Boolean functions is presented, and it is shown how such a representation permits the definition of concise and efficient APL routines to compute various useful logical combinations of these functions.
Use of virus functions to provide a virtual APL interpreter under user control
Authors: Gunn J. B.
Published: January 2007

By inserting a simple statement at the beginning of an APL function, it is possible to cause the execution of a reconstructed version of the function, rather than of its original statements. This reconstruction can simulate the effect of an arbitrary change in the APL language; thus, the APL programmer can have available a private, “virtual” version of the interpreter

We show some general- and special - purpose functions which can be used for this purpose, and give elementary examples of their application.
RIPO
Authors: Hendres Laurle J.
Published: January 2007

In this paper we describe an automated database prototyping tool that is based on a relational style data model and nested arrays. The tool is described in terms of of its input, a set of rosters (relations), and its output, a database prototype. The design and implementation of the tool is discussed relative to nested arrays and the nested array language, Nial.
Using fullscreen-support and graphics in an end-user-friendly management information system
Authors: Hoesle Conrad H.
Published: January 2007

This paper is a report on the experiences gained in the combined use of APLDI, GRAPHPAK and GDDM to write an end-user-friendly management information system. It contains hints about fullscreen-support, menu-panel design, user- friendliness and graphics.
APL editor features for productivity and quality
Authors: Holls Timothy P.
Published: January 2007

This paper describes features for a full screen APL program-and-data editor which provide capability above and beyond basic text editing functions. These features result from the integration of numerous separate utility operations into the editor. The combined processes enable the APL programmer to be more productive while at the same time generate a higher quality result. One such implementation, EDITFS, modelled on SPF, is the basis of this description.
APL programming
Authors: Hooker Raymond C.
Published: January 2007

This paper seeks to provide insights into the psychological dynamics of programming in APL. These insights should allow the practitioner to better approach the APL programming environment and may stimulate more in-depth, empirical research into these psychological dynamics. The paper approaches APL both as a language and as a system which maps problems into solutions. The paper is analytical versus empirical in nature. The author draws on the plethora of work related to the topic of the paper in the development of a model of programming in APL.
Proposal for a prototyping kit
Authors: Jantzen Jan
Published: January 2007

The three-levelled ANSI/SPARC architecture for database systems forms a framework on which software prototypes can be built. The external level corresponds to screen panels, the conceptual level to the data model, and the internal level to the stored files of the prototype. The paper identifies prototype design tools and building-blocks with respect to this architecture. A screen design tool illustrates ideas using nested arrays. A novel aspect is, that the paper takes a step towards an operational formulation of the prototyping approach by emphasizing the computerized implementation.
Application development and control system (ADACS)
Authors: Körnemark Rolf
Published: January 2007

User friendly applications are very often menu-driven. ADACS (in this paper used as an abbreviation for
A
pplication
D
evelopment
a
nd
C
ontrol
S
ystem) is such a menu system for APL applications. This paper describes how

• menus are made

• applications are developed/maintained

• applications are executed

Using ADACS, application prototypes as well as regular APL-based production systems have been developed. As it is used to
develop
applications - where the developer is an ADACS end-user - as well as to
execute
applications generated by ADACS, it is necessary to separate these modes of operation and the kind of people involved. In this text the words
programmer
and
end-user
will be used for that separation.
An input-checking function for APL systems
Authors: Levine Richard
Published: January 2007

The subject of this paper is an APL utility function with simple, powerful, and coherent input-checking features. The function requests from the user some specific input, validates it, and returns a result in “massaged” form. CHECK embodies a consistent user-friendly approach to dialogue. It allows the user to enter HELP, STOP, END, “macros”, and other special entries. It also allows the user fairly unrestricted access to native APL. These design features will enhance many large applications.
The impact of APL2 on teaching APL
Authors: Polivka Raymond P.
Published: January 2007

With the advent of significant new features in APL, for example APL2, attention to and an understanding of the fundamental principles and concepts of APL is especially important. This expository paper is aimed primarily at the APL educator, present or future, and the person seriously pursuing a more in-depth mastery of the language. The paper states some of the underlying concepts and principles of the language and why they are important. Within the presentation several techniques which the author has found successful in conveying these concepts are stated. Finally, the fact that APL2 permits another new and different approach to problem solving is discussed and illustrated.
The future of programming—whither APL?
Authors: Searle John R.
Published: January 2007

Changes in the computing industry can be expected to maintain their spectacular growth rate of recent years. The implications of these changes for programming languages, and on the techniques required by computer software professionals, are briefly discussed. In particular, the role of APL in this changing environment is analysed, with the intention of identifying some deficiencies in the current status of the language. Possible modifications are then suggested, in order to develop APL into an even more useful and generally acceptable tool for problem solving.
Exact nonparametrics in APL
Authors: Streitberg Bernd , Röhmel Joachim
Published: January 2007

The authors present a new algorithm for the exact distribution of many nonparametric tests. The algorithm is based on a recursion formula that relates the distribution of where K1,...,Knare iid Bernoulli [1/2] and a1,...,anare fixed p-vectors, to the distribution of Tn-1. The core idea is to realize this recursion by shifts of the p - dimensional distribution of Tn-1in the computer main storage, which can be implemented efficiently in APL. We believe, that the method has achieved a breakthrough in the practical application of Fisher-Pitman permutation tests, but it can also be used routinely in the computation of many other tests by applying an initial transformation to the original data. A noteworthy example is the Wilcoxon test with arbitrary ties in the data, whose exact distribution can easily be computed for Nample 100.

In order to allow the direct use of these results, a complete list of the necessary APL programmes is included in the text.
INFO-FRAGA, a user friendly query language for large files and data bases
Authors: Söderström Peter
Published: January 2007

INFO-FRAGA has been developed at Skandinaviska Enskilda Banken and serves as the main tool for ad hoc data base and file access. The paper describes the reasons for building a query language in APL and some important applications. In addition, an overview of the system and its parts is provided, together with a discussion of some details of the implementation of APL, in particular how the compiler was constructed.
Practical guidelines for a user-friendly interface
Authors: Wade Jill
Published: January 2007

'User-friendly' is one of the more popular buzz-words currently in vogue within the information-processing community. Everyone pays lip service to the idea that building user-friendly systems is a good thing, but people are a little more vague about what this really means and how it can be accomplished. This paper suggests some of the key factors which make a system user-friendly, and presents ways in which this objective can be achieved. The bibliography contains several references that are specifically of use to the APL programmer, as well as many of more general interest.
Geometric transformations in APL
Authors: Wade John W.
Published: January 2007

While geometric transformations that scale, translate, and rotate are in commonplace use, especially in computer graphics, they can be written and used very differently in APL. Because the plus/times inner product is a ready-made matrix multiplier, each transformation function has only to focus on organizing the transformation matrix for the envisioned use. Since inner product generalizes to arrays of higher dimension, a 3-D transformation array can be used to generate multiple objects each transformed as desired. The resultant object group is held in an array one rank higher than the original object that was transformed. With certain careful restrictions, such a resultant can be transposed to collapse along a principal diagonal, and produce an object of the same rank as the original object, but with its component parts transformed differently. For example, each latitude of a cylinder can be scaled differently to produce a curvilinear figure of revolution.
APL learning bugs
Authors: Eisenberg Murray , Peelle Howard A.
Published: January 2007

This paper discusses common mistakes novices make when learning to program in APL. We present several exemplary APL “learning bugs”, describe the context in which they occur, indicate why we believe they are interesting, and speculate about underlying thinking processes. We claim that such learning bugs are worth examining: further study may yield insight into barriers to wider acceptance of APL, better understanding may lead to more effective APL teaching, and deeper analysis may hold implications for APL designers.

bug...1: obs: bogey, bugbear (bugaboo): an imaginary object of fear; a source of concern

2: an insect or other creeping or crawling invertebrate...

3: an unexpected defect, fault, flaw, or imperfection

4: a disease-producing germ; also: a disease caused by it

5: a fad

6: enthusiast, hobbyist (obs: a crazy person)

7: a prominent person

8: a concealed listening device

9: a handicap

(adapted from Webster's New Collegiate Dictionary, G. & C. Merriam Co., Springfield, MA, 1977)
Increasing the use of APL
Authors: Myrna John W.
Published: January 2007

It appears that APL is used by only 5 to 10 percent of the programming population that might use it. After 15 years of commercial availability, many APL proponents find this a disappointing percentage. This paper reviews the main factors that inhibit the use of APL. It describes the factors, suggests means to overcome those factors, and gives examples of various APL systems that address the limiting factors.
An APL batch scheduler improves service and system management
Authors: Shrager Jeff , Hartman Lyle
Published: January 2007

An
APL.MS
2
system is described which enhances the behavior of the batch task scheduler for the Univac 90 series system: VS/9. In addition to permitting customized task control on a per-shift basis the system manager can interactively tune the system's batch load. The workspace communicates through operator commands and implements a simple algorithm which spreads the batch load so that both large and small tasks can execute. This work is an instance of the application of
APL
to systems programming in order to provide elegant interactive operating system tools.
Publications inventory control and distribution
Authors: Richardson Deborah R.
Published: January 2007

Most publications stocked by STSC, Inc. are produced at headquarters. A small number of other publications, however, are ordered from outside vendors and then stocked at headquarters for distribution. Past procedures for inventory control and distribution provided inconsistent data and no means for allocating costs to publications and charging them back to requests. This paper describes the design of STSC's inventory control and distribution system using the APL*PLUS® Data Management System. Although this system was implemented to solve a specific problem, its design provides a general-purpose tool for tracking and allocating costs for stocked items to consuming cost centers.
Interfacing APL and SQL
Authors: Hagenbuch Brian , Gardner Martin
Published: January 2007

We briefly argue that APL and a relational DBMS are a natural match for application development. We consider four pragmatic questions of interfacing APL and SQL: representation of query results, representation of SQL statements, SQL parameterization, and context control. We conclude with a brief mention of three APL/SQL implementations: one complete, one in progress, and one proposed. We do not discuss the fascinating question of how relational DBMS functions might be added as APL language extensions.
Cooperating input and output stack processors
Authors: Skutt Cory F.
Published: January 2007

As a complement to an enhanced input stack processor (ISP), an output stack processor (OSP) has been produced that captures output lines from VSAPL, places them on a stack, and makes them available to an APL application through the shared variable interface. Together, these processors provide three fundamental facilities: execution of system command sequences; error and exception handling; and retrieval of information not available through system variables. This presentation discusses the objectives, challenges, design and applications of these processors. A brief comparison of error-handling capabilities is included.
Examples of event handling in APL2
Authors: Graham Alan
Published: January 2007

Event handling is a feature that has recently been added to many APL systems. IBM's VSAPL release 4.0 and APL2 include a dyadic system function @@@@EA (Execute Alternate) which provides a simple event handling facility. This dyadic function can easily be simulated using the event handling facilities offered by other vendors. Event handling provides a significant new direction in capability to APL. Some applications that are inconvenient or impractical are easily accomplished using event handling. The examples given show some novel uses that may not be obvious on first introduction to @@@@EA. Although the examples given here are specific to APL2 the ideas behind them may be used on any APL system with sufficiently powerful event handling.
Workspace interchange on microcomputers
Authors: Dickey L. J.
Published: January 2007

This note addresses some of the problems associated with moving APL workspaces to and from micro-computers that run APL. Some solutions are proposed.
Using graphs to analyze APL functions
Authors: Metzger Robert
Published: January 2007

The purpose of this paper is to show how graphs can be used to analyze
APL
functions. Several kinds of graphs are introduced. In each case,
APL
functions which generate matrix representations of these graphs derived from
APL
programs are presented. Then,
APL
functions which compute measures of the quality of a program based upon these graphs are suggested.
An inflation management system
Authors: Fox Mary Lou
Published: January 2007

This paper presents an overview of SOLUTION-33, a large financial software product which was developed to meet the need of major corporations to comply with the 1979 Statement 33 of the Financial Accounting Standards Board. Intended for application programmers, the paper discusses design goals and technical design issues. The innovative approaches of this product include its design as a package financial product to meet a specific need of major corporations, its use of existing software as building blocks, and its extensive capability for customizations which can be sewn into the application without difficulty while protecting the security of the production APL code.