APL conference

While many conferences and sequences of conferences have been held by the array language community, the term APL conference refers to a sequence of conferences held once per year, with some lapses, beginning in 1969, and ending in 2010 with no plans for future conferences. Initial conferences were organised by various universities or other institutions, with some connection to SHARE but no particular central authority. Beginning with the 1974 conference, APL 6, SIGAPL (or STAPL at the time) took over organization of the conferences. Conferences in 1977 and 1978 were not held primarily because of logistical failures, an occurrence which may have prompted vendors to begin holding their own IPSA and STSC conferences, but resumed afterwards and continued to be held every year until 2004. When no conference was arranged for 2005, Dyalog Ltd. began hosting its yearly Dyalog user meetings beginning in 2006, with both events happening in 2007. The last conference was held in 2010: organized in association with APL Germany and integrated with Dyalog's user meeting that year, it was seen as part of a sequence with the 2000 conference also in Berlin, but this sequence was not extended to 2020.

Conference details

Year	Location	Title	Date
1969	S.U.N.Y Binghamton, New York, USA	The Conference on APL "The March On Armonk"	July 11–12, 1969
1970	Goddard Space Flight Center, Greenbelt, MD, USA	APL II	June 19–20, 1970
1971	Berkeley, CA, USA	APL III	April 20–21, 1971
1972	Atlanta, Georgia	APL IV	June 15–16, 1972
1973	Toronto, Ontario	APL V	May 15–18, 1973
1974	Anaheim, CA, USA	APL 6	May 14–17, 1974
1975	Pisa, Italy	APL75	June 11–13, 1975
1976	Ottawa, Canada	APL76	September 22–24, 1976
1978	Foothill College, Los Altos Hills, CA, USA	"APL78" (unofficial)	March 29, 1978
1979	Rochester, NY, USA	APL '79	May 30–June 1, 1979
1980	Leeuwenhorst, Noordwijk, Holland	APL '80	June 24–26, 1980
1981	San Francisco, CA, USA	APL '81	October 21–23, 1981
1982	Heidelberg, Germany	APL '82	September 1982
1983	Washington, D.C	APL '83	April 10–13, 1983
1984	Helsinki, Finland	APL '84	June 11–15, 1984
1985	Seattle, WA, USA	APL and the future	May 12–16, 1985
1986	Manchester, UK	APL in Action	July 7–11, 1986
1987	Dallas, TX, USA	APL in Transition	May 10–14, 1987
1988	Sydney, Australia	APL '88	February 1–5, 1988
1989	New York City, NY, USA	APL as a Tool of Thought	August 7–10, 1989
1990	Copenhagen, Denmark	APL 90: For the Future	August 13–17, 1990
1991	Palo Alto, CA, USA	APL '91	August 4–8, 1991
1992	St. Petersburg, Russia	APL '92	July 6–10, 1992
1993	Toronto, Ontario, Canada	APL '93	August 15–19, 1993
1994	Antwerp, Belgium	The Language and Its Applications	September 11–15, 1994
1995	San Antonio, Texas, USA	Applied Programming Languages	June 4–8, 1995
1996	Lancaster, UK	Designing the Future	July 29–August 1, 1996
1997	Toronto, Ontario, Canada	Share knowledge / share success	August 17–20, 1997
1998	Rome, Italy	APL98 Conference on Array Processing Languages	August 27–31, 1998
1999	Scranton, Pennsylvania, USA	All Array Programming Languages	August 10–14, 1999
2000	Berlin, Germany	Think Arrays in a Great City	July 24–27, 2000
2001	New Haven, Connecticut, USA	An Arrays Odyssey	June 25–28, 2001
2002	Madrid, Spain	Array Processing Languages: Lore, Problems, and Applications	July 22–25, 2002
2003	San Diego, California, USA	Stretching the Mind	June 11–14, 2003
2004	Montreal, Canada
2007	Montreal, Canada	Arrays and Objects	October 21–26, 2007
2010	Berlin, Germany	APL 2010 LPA	September 12–17, 2010

Past conferences

1960s

1969

The first APL conference was held at SUNY Binghamton, the first university with an APL system and sponsor of the conference, July 11–12 of 1969. It was called "The March on Armonk" after IBM's headquarters in Armonk: although attendees did not travel to Armonk, many came to make demands of IBM as they might at a march. Its stated goals were

(1) to bring together as a community of users those, primarily in university environments, who were using the APL\360 Terminal System;
(2) to indicate to IBM, both by what would transpire and by the volume of response, that the acceptance of the APL language had grown in a short period of time to an unusually high degree.

The high attendance of roughly 220 was due in part to IBM sales people: as IBM had recently begun to sell APL\360 as a stand-alone product, those in sales sought to learn about the language.

Attendee Garth Foster was motivated by the diverse interests represented at SUNY to rename his newsletter SHARE*APL\360 to the APL Quote-Quad, and to establish the APL Implementer's Workshop. The latter served to bring the behavior of various APL implementations into closer alignment by offering implementors a forum to discuss design and implementation decisions.

A point of focus in early APL conferences was CAI, which stands for Computer Assisted Instruction. Sometimes the acronym CAL, or Computer Assisted Learning, is also used.

• Introduction. James A. Higgins. [1].
• Welcoming address. G. Bruce Dearing. [2].
• APL\360 history. Adin Falkoff. [3] (web).
• Session I: University applications. [4].
• Session II: CAI in APL. [5].
• Session III: Teaching the APL language. James Higgins. [6].
• The status and future of APL (Panel Discussion). Roberson Higgins. [7].
• Special interest groups. [8].
• Questionnaire results. [9].

1970s

1970

At the suggestion of NASA employee Cyrus Creveling, a group of attendees of the 1969 conference agreed to hold a second conference at the Goddard Space Flight Center in Greenbelt, Maryland. It took place on June 19 and 20, 1970. The conference, reduced in attendance from 220 to 150, was held in the style of a workshop, with presentations and discussion but no papers or proceedings published. At this conference the first formal effort to establish SIGAPL was made by collecting the required 25 signatures for a petition to the ACM.

Two reports from the conference were published in the APL Quote-Quad. Ken Iverson and Adin Falkoff attended but spoke little about their plans, and Eric Iverson, then at I.P. Sharp, participated in discussion.

• Telemetry Data Processing. George H. Ludwig (NASA).
• Demonstration of an APL On-line Shared files system developed by Larry Breed and Eric Iverson at I.P. Sharp. Al Rose (STSC).
• APL and Files on the IBM 1500. Henry T. Lippert (Florida State University) and Tom McMurchie (USAF).
• File Management System. Gerry Enfield (Computer Company, Richmond).
• APL\360 file handling. Brooks White and John Rose (Agoranomic Teleprocessing Systems).
• APL File-handling panel.
• Scientific Analysis of Telemetry Data and the Need for File Linkages and Large Data Bases. James Kinsey (NASA).
• Some thoughts on Scalars, Commands and other aspects of APL. Jim Ryan (Burroughs).
• An APL Implementation on the Univac 1108. Pat Haggerty (University of Maryland).
• Possible extensions to APL notation for graphics. Lynn Yarbrough (Arcon Corp).

1971

The next APL conference was held at University of California on April 20 and 21, 1971. Again there were no formal proceedings, but summaries of each talk were printed in the next issue of the APL Quote-Quad. Following the failure of the petition to form SIGAPL produced at the previous conference, some attendees suggested forming an organization independed of the ACM, but Alan Perlis, a former ACM president, argued instead to continue working with the ACM.

• APL as a Conversational Language - What is Missing? Alan Perlis.
• A Set of APL Programs for Use in Network Theory. Paul Penfield, Jr. (MIT).
• An On-Line Proof Checker Operating under APL/360, with Applications for Computer-Aided Instruction in Logic, Mathematics, and Computer Science. Paul Page (UCLA). [10].
• The CDC Star-100: An APL Oriented Machine.
• Conditional Branch, APL Compiler. John Williams (Cornell)
• A Language Machine. Zaks and Steingart (UC Berkeley). [11].
• Bulk I/O and Communications with LTSS. Jerry L. Owens (Livermore Time Sharing System).
• Generalized Lists and Other Extensions. Jim Ryan (Burroughs).
• LRL APL Implementation on the CDC 6000-7600. Ned Dairike (Livermore Radiation Laboratory).
• Time Sharing APL for IBM 1130 Systems. Thomas P. Daniell (IBM)
• APL on the Honeywell 635. Norman Glick and Richard Schrader (NSA). [12].
• A Micro-Programmed Implementation of an APL Machine. A. Hassitt, J. W. Lageshulte, and L. G. Lyon (IBM).
• APL/700 - An APL Implementation for the Burroughs 6700 and 7700. Jim Ryan (Burroughs).
• An 8-bit ASCII code. John Fletcher.
• The MRX 1240 Communication Terminal and 1270 Transmission Control Unit. David Sant (Memorex Corporation).
• A Plotter of APL. Mike Dayton (Time Share Peripherals).

1972

The 1972 APL User's Meeting was held in Atlanta, Georgia on June 15 and 16. It was co-hosted by the Atlanta Public Schools Computer Center and Georgia Tech, and after the first day of presentations many participants toured the Computer Center, where APL was used including by students. Ken Iverson spoke at the closing luncheon the next day, discussing APL's development history and hinting at future directions. Submitted papers were refereed by Garth Foster.

• Is APL epidemic? or a study of its growth through an extended bibliography. J. C. Rault and G. Demars. [13].
• An APL approach to interactive display terminal graphics. W. H. Niehoff and A. L. Jones. [14].
• Graphics in APL. Alfred M. Bork. [15].
• An interactive APL graphics system. Stuart G. Greenberg and Craig I. Johnson. [16].
• Modeling a satellite experiment on APL. Charles D. Wende. [17].
• Representing negative integers in bit vectors. L. J. Woodrum. [18].
• APL as a teaching tool: Two versatile tutorial approaches. Leslie N. Davis, Jak Eskinazi, and Daniel J. Macero. [19].
• The evolution of an interactive chemistry laboratory program. Thomas R. Dehner and Bruce E. Norcross. [20].
• A collection of graph analysis APL functions. E. Girard, D. Bastin, and J. C. Rault. [21].
• Management of APL time-sharing activities. J. Higgins and A. Kellerman. [22].
• Every little bit hurts: Saving money by saving space in APL. Richard Alercia, Robert Swiatek, and Gerlad M. Weinberg. [23].
• Security of APL applications packages. Paul Penfield. [24].
• A PL/1 batch processor for APL. S. Charmonman and J. E. Bell. [25].
• Subtasking in APL. Alain Miville-deChêne and Louis P. A. Robichaud. [26].
• Suggestion for a “mapped”, extension of APL. C. Leibovitz. [27].
• APL as a notation for statistical analysis. K. W. Smillie. [28].
• An adaptive query system. E. Kellerman. [29].
• Microprogram training - an APL application. Ray Polivka and Kent Haralson. [30].
• ECAPL-An APL Electronic Circuit Analysis Program. Randall W. Jensen, Terry A. Higbee, and Paul M. Hansen. [31].
• Use of APL in teaching electrical network theory. Paul Penfield. [32].

1973

The 1973 conference proceedings were published by Canadian Printco Limited, not the ACM.

• Teaching children thinking via APL. H. A. Peelle.
• Teaching APL. K. P. Carolan.
• An introductory APL self-teaching package. D. Watson.
• Motivating arrays in teaching APL. G. H. Foster.
• The variety of definitions of a simple function. E. E. McDonnell.
• Techniques in programming CAI with APL. J. R. Clark and R. Mercer.
• A table-driven program to play a game of logical deduction. S. Charmonman and D. K. Reed.
• Communication, computers, and the classroom. L. N. Davis, J. Eskinazi, and D. J. Macero.
• A simulator for use of an APL computer in science teaching. G. Bartoli, L. Bartolo, and V. Spadavecchia.
• APL as an aid to the teaching of undergraduate economics. J. R. Savary.
• APL as an analytic notation. K. E. Iverson.
• Formal differentiation using APL. G. Wilhelmi.
• Proposed notation and implementation for derivatives in APL. P. Penfield.
• Permutations. M. M. Halpern.
• Xerox financial planning and control system in APL. J. W. Rough.
• The brownbox information retrieval system. D. Flower.
• An application of the binamila distribution to sales planning. H. M. Courtney and C. M. Cheney.
• Administrative datafile handling via APL. W. R. Tinga.
• APL for information management and CI. D. Vaskevitch.
• APL/11 - A poor man's APL. D. G. Moffat and M. A. Jenkins.
• Simulating computers in symbolic assembler notation. H. J. Saal.
• Application of a hybrid (two-mode) processing system. P. H. Russel, L. Wagshal, and J. C. Wiginton.
• An APL translator for the B6700. I. M. Braude and M. A. Jenkins.

1974

• The extended file system at GSFC. May W. Adams. [33].
• A time study in numerical methods programming. Glen B. Alleman and John L. Richardson. [34].
• Towards an APL compiler. E. A. Ashcroft. [35].
• APL optimization: A unified approach. G. Battarel and D. Tusera Laboria. [36].
• Algebraic manipulation. J. W. Bergquist. [37].
• APL as a language for interactive computer graphics. Alfred M. Bork. [38].
• An application of a specialized data bank for analysis and information retrieval in the field. James A. Brown and Bernaro Verner. [39].
• Management information/decision systems using APL. John G. H. Carlson and Richard Gilman. [40].
• Conversational building and display of solid objects. V. Casarosa and S. Trumpy. [41].
• Development of a Batch APL System. James F. Clementi and Peter Sandery. [42].
• “INSTANT CAI”. R. F. Conklin. [43].
• A generalized multi-stage cost minimization model in APL. Harley M. Courtney. [44].
• APL unary matrix operators as represented by the eighth order Dihedral group. John H. Crayton. [45].
• APL and its entry into the world (?). Cyrus J. Creveling. [46].
• Techniques for computer administered examinations of restricted or confidential material. Leslie N. Davis and Daniel J. Macero. [47].
• Application of APL/360 in junior high school. David DeBarthe. [48].
• APL\INFO: A system for automatic documentation. P. Dell’orco and L. Bartolo. [49].
• The use of APL in the management of a time sharing company. Daniel Dyer. [50].
• Controlling numerically controlled machines using APL. E. J. Fancher. [51].
• Large scale mathematical programming in an APL environment. R. S. Goncharsky, A. Rauch, and W. W. White. [52].
• A computer system providing microcoded APL. Charles A. Grant, Mark L. Greenberg, and David D. Redell. [53].
• A batch processing version of APL 1130 for student use. Joel D. Hail and Joel D. Kirscher. [54].
• Development of a monitor-compatible version of APL 1130. Joel D. Kirscher and Joel D. Hail. [55].
• A first APL tournament package. M. J.D. Hopkins, H. G. Morin, and T. V. Narayana. [56].
• APL and MIS: Two compatible concepts. Rolland A. Hurtubise. [57].
• APL as a foundation for a Marketing Planning and Analysis System. W. F. Jarvis, H W. Wobbe, and H. Carim. [58].
• Cross-country scoring and timing using APL. Alan L. Jones. [59].
• A graphical input capability for APL. A. L. Jones and R. H. Katyl. [60].
• A fast formatter for APL. Warren Juran. [61].
• APL tools for combinatorics. Eduardo Kellerman and William C. Rodgers. [62].
• An investigation of curve fitting methods using an APL graphics terminal. Anne Kellerman. [63].
• Teaching beyond elementary APL to applications users: Principal author. Anne Kellerman and Jeanine Meyer. [64].
• APLGOL-2 a structured programming language system for APL. Robert A. Kelley and John R. Walters. [65].
• A spline package in APL. Robert J. Korsan. [66].
• Power system load flow in APL. Wilbur R. LePage and Lowell E. Lingo. [67].
• Evaluating the equality or inequality of symbol strings in APL. Geraldine MacDonald. [68].
• Programming aids in Xerox APL. William J. Maybury. [69].
• The caret functions: Efficient algorithms for scans and reductions of eight Boolean functions. E. E. McDonnell. [70].
• The use of APL in management education. Ephraim R. McLean. [71].
• Uses of general arrays and operators. J. E. Mezei. [72].
• Character string manipulation in APL. Charles R. Moore. [73].
• The PCS APL shared file system. Warren Juran, Charles Moore, Carl Orndorff, and Larry Rice. [74].
• ISP/1: A conversational statistical package. Michael D. Murray. [75].
• Contour plotting in rectangular domains—an APL approach. W. H. Niehoff. [76].
• APL and FORTRAN: A Symbiotic Mix for a Small Machine. C. P. Nielsan, T. H. Burnett, and W. Vernon. [77].
• APL Data Management Systems (APLDMS). Salomon Ohayon and Pierre A. Lavallee. [78].
• APL\XAD: An extension of APL for abstract data manipulation. Michael D. D’Dell and John C. Thompson. [79].
• Flexible building of specialized information retrieval systems application to the management of APL functions as a programming aid. Jean-Claude Pages and Anne Mauboussin. [80].
• “A generalized learning” game. Howard A. Peelle. [81].
• A CAI system based on modifications to York/APL. Steve Peterson. [82].
• Improved security in APL applications packages. Thomas H. Puckett. [83].
• Scalar Segment Processor for APL. Yves G. Raynaud and Louis P.A. Robichaud. [84].
• The Newton Cotes coefficients in APL. John L. Richardson. [85].
• Lexical and syntactic analysis of APL, generation of a prefix polish string. [86].
• CASPER. William A. Rux. [87].
• An APL catalog system. James Schenck, John Peetz, and Chris Clausen. [88].
• The use of APL in the teaching of probability. K. W. Smillie. [89].
• A virtual-variable name-specification operator for high level languages. A. J. Surkan. [90].
• The financial planning system - the application of APL to financial modeling. Paul A. Tava. [91].
• Budget planning and costing in xerox APL. [92].
• A graphics system for APL users-APL/Graph-II. Larry Koenigsberg and Ned Thanhouser. [93].
• APL/CAT: APL for computer assisted teaching. David Vaskevitch. [94].
• Shared information management system. Kevin R. Weaver. [95].
• Communications between users in a dispersed A.P.L network. Charles Weiss. [96].
• A modest information system implemented on APL. Charles D. Wende. [97].
• The case for APL standards. Clark Leamann. [98].
• Speech synthesis under APL. Donald B. Rueter. [99].

1975

• What’s wrong with APL?. Philip S. Abrams. [100].
• SIAL/74 - an APLSV analog-logical block-diagram simulator. M. Alfonseca. [101].
• A formal definition of APL statement syntax. Everett F. Allen. [102].
• A portable APL translator. A. Andronico, G. Leoni, and E. Luciani. [103].
• Executable models in APL to introduce concepts in computer science. G. Bartoli, L. Bartolo, P. C. Berry, and V. N. Spadavecchia. [104].
• APLSV for a flexible man-computer dialog. J. Beetz. [105].
• Large scale gymnastics championships: An on-line interactive collection and analysis of scores. Daniel L. Bernitt, James S. Walton, and Frederick S. Bader. [106].
• Content analysis of APL defined functions. Harvey W. Bingham. [107].
• APL authorization processing. JOHN R. BLANCHARD. [108].
• APLSV access to indexed sequential files. Gordon W. Chamberlain and Michael E. Massey. [109].
• An approach to a multifaceted student information system in large medical school.. F. Clancy, S. Hoke, and T. Mullan. [110].
• APL as a statutory language. Harley M. Courtney. [111].
• Systems programming tools. Harold A. Driscoll. [112].
• APL functions for precision control in floating-point computations. Augustin A. Dubrulle. [113].
• An extension of the domain of the APL domino function to rank deficient linear least squares systems. Augustin A. Dubrulle. [114].
• What lies beyond the branch arrow?. Garth H. Foster. [115].
• Node synchronization in a distributed computer network. P. Franchi, T. Pedrotti, and G. Sommi. [116].
• A design for APL software for man-machine dialogue with statistical applications. Michael L. Friendly and Richard M. Levine. [117].
• Assertions and APL programming. Susan L. Gerhart. [118].
• Remote job entry and output through APL. Uday G. Gujar. [119].
• Medical applications of data-driven APL programs. W. Hagamen, W. Bell, J. Lincoln, D. Linden, and J. Weber. [120].
• Efficient implementation of APL in a multilanguage environment. B. Hakami. [121].
• A network approach to APL implementation. M. D. Harbinson and L. J. Howard. [122].
• Event variables - on conditions for APL. Thomas J. Harris. [123].
• Edge-labeled directed graphs in APL. Lyle G. Hartman. [124].
• Direct execution of APL on an IBM/370. A. Hassitt and L. E. Lyon. [125].
• Translating APL, an empirical study. M. A. Jenkins. [126].
• The design of an APL primitive function for the eigenproblem. M. A. Jenkins. [127].
• Interactive analysis of time series. Seppo Kaltio. [128].
• APL symbolic manipulation and generating functions. A. Kellerman. [129].
• Teaching data base concepts using APL. J. Klebanoff, F. Lochovsky, and D. Tsichritzis. [130].
• On-line interpreted batch APL. Naomi Geller Kleid and Gerald M. Weinberg. [131].
• A new array indexing system for APL. G. R. Lewis. [132].
• A notation for the GCD and LCM functions. E. E. McDonnell. [133] (web).
• Two methods of using APL in the teaching of probability and statistics. U. M. von Maydell and K. W. Smillie. [134].
• An APL environment for testing relational operators and search algorithms. F. P. Palermo. [135].
• Application of APL for rapid verification of a digital system architecture. Behrooz Parhami. [136].
• An APL interpreter written in APL. Paul Penfield. [137].
• The york APL command processor for TSO. Enio Presutto. [138].
• Word processing functions. Samuel Waldo Reynolds. [139].
• Process control languages and APL. J. A. Richter. [140].
• APL[LAVAL] used as an interactive tool for the description, simulation and micro-programming of digital computers. Louis P.A. Robichaud, Yves Ouellet, and Gerard Simian. [141].
• Some properties of APL programs. Harry J. Saal and Zvi Weiss. [142].
• Plots related to subgradient optimization. Claudio Sandl. [143].
• A generalized APL shared variable system. Subramanya K. Shastry. [144].
• EASY and AVS: The two auxillary storage subsystems of the MCM/70. J. Morgan Smyth. [145].
• Hospital administration of large numbers of multi-trauma patients. Mitchell Snyder, Bruno Lunenfeld, and Daniel Lieberman. [146].
• Structure of an Inf-Doc-System and its realization as an Experimental System in APL plus. H. Steinhauer. [147].
• On-line video computer feedback of teaching performance. A. J. Surkan, T. Hoover, and L. Campbell. [148].
• Bizarre APL solutions. Roy A. Sykes. [149].
• EMMA: Extended management macros in APL. Roy A. Sykes and Robert R. Decloss. [150].
• A segmented transformed display file for APL GRAPH-II. Ned Thanhouser. [151].
• Some combinatoric algorithms in APL. Norman D. Thomson. [152].
• Experimental comparison of two interpretation methods of APL.. Dimitri Tusera. [153].
• An APL package for convex geometry. Richard A. Vitale and Alan J. Tarr. [154].
• APLODS. James R. Wilson and Alan M. Marcum. [155].

1976

• “Extension of APL to tree-structured information”. M. Alfonseca and M. L. Tavera. [156].
• A generalized digraph simulator. Brooke Allen. [157].
• AQL: An APL based system for accessing and manipulating data in a Relational Database System. F. Antonacci, P. Dell’Orco, and V. N. Spadavecchia. [158].
• Reorganization of the APL libraries. E. Armitage, J. Chenier, C. Leibovitz, D. Precht, and Y. Zia. [159].
• GOFER: A system for evaluating projects in the petroleum industry. Frank B. Arthur. [160].
• Investment Analysis application + style. J. Beetz. [161].
• A modular approach to teaching management science and statistics using APL. Dale H. Bent and Girard C. Pessis. [162].
• Distributive rounding in commercial applications. Paul Berry. [163].
• TEXTEDITing using APL/700. Harvey W. Bingham. [164].
• Dynamic usage of APL primitive functions. Harvey W. Bingham and Kenneth T. Carvin. [165].
• York APL-total database interface. Ian M. Cuthill. [166].
• Instructional databases in APL. Cecil E. Denney and Ronald E. Converse. [167].
• APL functions which enhance APL branching. J. P. Dorocak. [168].
• Keyed files for databases in Sharp APL. M. Elliott. [169].
• Hierarchical data management. Jan M. Engel. [170].
• A general interactive guidance for information retrieval and processing systems. R. Erbe and G. Walch. [171].
• Some implications of shared variables. Adin D. Falkoff. [172].
• The ACTION/FILES file system. John S. Fisher. [173].
• GPMS, a general purpose memory management system—user’s memory—that is.. I. Ganapathy and R. F. Hobson. [174].
• ΔEditor APL function and data maintenance system. R. G. Germain and J. W. Burgeson. [175].
• A simple approach to the empty generalized APL arrays. Ziad Jamil Ghandour. [176].
• Adding a modern control structure to APL without changing the syntax. W. K. Giloi and R. Hoffmann. [177].
• High level data management for the problem solver. Stuart G. Greenberg. [178].
• Recursive data structures and related control mechanisms in APL. W. E. Gull and M. A. Jenkins. [179].
• Interactive computing and the manager-machine interface. Art Guthrie. [180].
• The design, development and operation of an APL-based MIS: The case of a small firm. Rolland A. Hurtubise and Yves Poulin. [181].
• Two combinatoric operators. Kenneth E. Iverson. [182].
• APL function editing in APL. Arto Juvonen. [183].
• Adaptive library documentation for APL. Naomi Kleid and Gerald M. Weinberg. [184].
• Functions in APL to assist the programming and servicing of CAI-Lessons. Georg R. Lampl and Isolde Schell-Haungs. [185].
• APL comparison tolerance. R. H. Lathwell. [186].
• APL usage in Europe: Scope and value. Yves Le Borgne. [187].
• Data Base Retrieval System (DBRS) a personalized data base system for the APL user. C. E. Mahood. [188].
• APL as implementation language for financial data bases. George R. Mayforth. [189].
• Zero divided by zero. E. E. McDonnell. [190] (web).
• Interactive computing in a course on numerical analysis. James E. McKenna. [191].
• The use of APL for production applications: The concept of “throwaway code”. Ephraim R. McLean. [192].
• Toward a data structure extension for APL. Wm J Mein. [193].
• Toward a primitive recursive semantics for APL. Richard J. Orgass. [194].
• APL used for management in a reprocessing plant. Bruno Petruschka. [195].
• APL forecasting system. Jack Prins. [196].
• An application of tree structures to an interactive double-entry bookkeeping system. Sander Rubin. [197].
• Application diagnostic aids in APL/700. James L. Ryan and Harvey W. Bingham. [198].
• A case study of putting APL to work with a large database. James K. Schmidt. [199].
• APL Econometric Planning Language (EPLAN). F. Schober and K. Spielberg. [200].
• A numeric-controlled formatter. G. M. Seeds and A. Arpin. [201].
• A planning and design technique. J. Siller. [202].
• Regression analysis: Theory and computation. K. W. Smillie. [203].
• Least squares estimation of C.E.S. production function’s non-linear parameters. G. Soda and E. G. Vichi. [204].
• Automatic workspace analysis and documentation. Joseph Specht. [205].
• APL algorithm for a sequential search for a hidden target in a two-dimensional region. A. J. Surkan. [206].
• Using APL to monitor APL. Anton G. Wellbrock, John W. Mizzi, and Richard D. Moore. [207].
• A general personnel information retrieval system in APL. K. K. Wing and Y. K. Wong. [208].
• APL in Computer-Assisted Instruction: Simulation of Stochastic Processes in science teaching. S. W. Wittig and R. Eggensperger. [209].
• Index. [210].

1979

The 1979 APL conference was held in Rochester, New York from May 30 to June 1, and sponsored by SIGAPL (then STAPL). In part due to the lack of formal 1977 and 1978 conferences, attendance was very high, with over a thousand attendees and 200 submitted papers. Abstracts could be submitted electronically by the major APL time-sharing services. Eight invited papers, presented to all participants, were given by notable computer scientists both inside and outside the APL community. In addition to talks, the conference featured a poster display and exhibits of APL implementations, terminals, and books. A banquet talk was given by Fred Brooks, with the title ⍉ 1 3 ⍴ 'APL' ⍝ A Sideways View of APL.

• Deferred Execution: An “ACE” of an application. Donald A. Link and Martin W. Gardner. [211].
• Multisystem processing with APL. J. F. Sencindiver and D. H. Steinbrook. [212].
• APL2M: Cross-computer software for straightforward language definition and code generation. Jean A.P.L. Rohmer. [213].
• Designing efficient algorithms for APL: A case study of a hydraulic-network solver. Emanuel Gofman and Michael Rodeh. [214].
• Determining probability distributions by maximum entropy and minimum cross-entropy. Rodney W. Johnson. [215].
• A neurologic diagnostic model of the human brain. Grace M. Hucko and W. D. Hagamen. [216].
• Laminar extension: An overlooked capability and the search for its proper home. George Mebus. [217].
• Fuzzy residue. Eugene McDonnell. [218] (web).
• Proposal for a complex APL. Paul Penfield. [219].
• Relational data-base management and APL. E. F. Codd. [220].
• The nested rectangular array as a model of data. Trenchard More. [221].
• A software high performance APL interpreter. Harry J. Saal and Zvi Weiss. [222].
• The Dynamic Incremental Compiler of APL\3000. Ronald L. Johnston. [223].
• Tentative compilation: A design for an APL compiler. Terrence C. Miller. [224].
• The application of APL to control more efficient processes. A. P. Reeves. [225].
• GESOP: A relational data base using generalized arrays and data-base primitives. Michéle Pierre and Philippe Pierre. [226].
• Array theory in an APL environment. A. Hassitt and L. E. Lyon. [227].
• Visions: A computer-graphics notation. Judson Rosebush. [228].
• A note on pattern matching: Where do you find the match to an empty array?. Adin D. Falkoff. [229].
• Sorting - a new/old problem. Howard J. Smith. [230].
• The role of operators in APL. Kenneth E. Iverson. [231].
• Statistical software in APL: Bibliography. Richard M. Heiberger. [232].
• Implementations of APL on small computers. Ronald F. Bauer. [233].
• Nested arrays as an extension for APL. Michael A. Jenkins. [234].
• Automatic control of execution: An overview. Philip S. Abrams and John W. Myrna. [235].
• Evaluating extensions to APL. J. A. Brown. [236].
• Nested rectangular arrays for measures, addresses, and paths. Trenchard More. [237].
• An electrical-filter synthesis package based upon vector-space operations. T. G. Marshall and F. C. Liu. [238].
• APL and a Black-Box theory of electric circuits. John C. Wilson. [239].
• Implementation of an APL-driven laboratory interface. R. V. Edwards, J. Gertler, J. A. Mann, F. Kucera, S. Herndon, and T. Gall. [240].
• Structured development of menu-driven application systems. John Sigle and John E. Howland. [241].
• Menus with APL, and other full-screen applications. Terry McKee. [242].
• An airline-industry database. N. L. Ensenat, G. S. Rosen, and F. F. Speckman. [243].
• The MACSYMA system for formula manipulation. J. Moses. [244].
• Constraints. Guy Lewis Steele and Gerald Jay Sussman. [245].
• Efficient storage management in APL. Roy A. Sykes. [246].
• Programming with idioms in APL. Alan J. Perlis and Spencer Rugaber. [247].
• A toolbox for APL programmers. Robert C. Metzger. [248].
• A latent-expression exception-handling system. John C. Gilmore and Thomas H. Puckett. [249].
• APL/Z80: An APL interpreter for Z80 microcomputers. John E. Howland and Philip Van Cleave. [250].
• Secure application environments in APL\3000. Alan M. Marcum. [251].
• QAS*APL: A step towards program-free interactive problem solving. Jim Goff and Milos Konopasek. [252].
• APL and the Grzegorczyk hierarchy. Seth Breidbart. [253].
• A general method for locally optimal search. Allen J. Friedman. [254].
• APL and LISP—should they be combined, and if so how?. William H. Burge, Joel Moses, Vaughan R. Pratt, and Alan J. Perlis. [255].
• An APL system-development facility. Douglas W. Flower and Maurice Elliott. [256].
• Using an APL macroprocessor to implement generalized software systems. Mark R. Dempsey. [257].
• An overlaying method for the effective organisation of APL systems. A D Crossley and G R Streeter. [258].
• APL modeling of DeMorgan algebras. Terence J. Reed. [259].
• The geometric primitives of APL. N. D. Thomson. [260].
• Teaching computer science with APL: An introduction to search procedures. Stewart A. Denenberg and Howard A. Peelle. [261].
• Steps toward an APL compiler. Clark Wiedmann. [262].
• Some implications of APL order-of-execution rules. Richard H. Lathwell. [263].
• On the locus of program flow within and among secondary functions. Garth H. Foster. [264].
• Smalltalk and generic concepts in programming languages. Alan C. Kay. [265].
• Development of an APL standard. A. D. Falkoff and D. L. Orth. [266].
• The derivative operator. Kenneth E. Iverson. [267].
• Operators and uniform forms. Douglas J. Keenan. [268].
• A programming technique for non-rectangular data. Bob Smith. [269] (pdf).
• An interactive APL simulation of hospital critical-care units. Donald Segal. [270].
• Interactive simulation gaming for energy-policy analysis. Peter D. Blair. [271].
• Management of APL public libraries. Marguerite A. Boisvert. [272].
• Information retrieval with APL by adaptive index and user guidance. Hans-Joerg Schek and Georg Walch. [273].
• A primitive-function APL keyed file system. Geoffrey Wiland. [274].
• An APL-total interface. Rick Mayforth. [275].
• Development of an APL standard. A. D. Falkoff and D. L. Orth. [276].

1980s

1980

Proceedings of the 1980 APL conference were published by North-Holland Publishing company (now part of Elsevier), and not by the ACM.

• Notation as a tool of thought. K. E. Iverson. (web).
• The use of the inner-product operator of APL in graph applications. G. A. Blaauw and A. J. W. Duijvestijn.
• Microprocessor software development using APL. F. Cesarini and G. Soda
• The execute primitive function; how it widens the perspective of APL-programming. W. M. H. Rutten.
• The use of APL in large applications. G. R. Mayforth.
• Civilising APL: an approach to integrated APL systems. D. Mathieson, R. Shaw, and J. White.
• Budgeting for large APL projects. S. Taylor and K. S. Andersen.
• Simulating power systems in APL. A. Wellbrock.
• Simulation of cash office set-ups. Th. A. M. van den Bruele.
• APL*DS - an APL-based hardware specification simulation system. W. K. Giloi and P. M. Behr.
• An experimental facility of inter-virtual-machine communication between APL and non-APL systems. M. Udo and S. Uno.
• An APL compiler or the production environment. J. D. Sybalsky.
• An alternative design for an APL engine. G. H. Foster and D. P. Fenster.
• APL as a language for application prgrammers. G. R. Mayforth.
• Concepts of structure in APL. B. R. Martin.
• Applications of local functions in APL. S. B. Jaffe.
• Generic programming, APL, and Smalltalk. A. C. Kay.
• Large applications in APL. Ph. S. Abrams.
• Multiple execution environments in APL. A. M. Marcum.
• The solutions of linear systems in APL: towards and extension of matrix divide. G. A. Martin.
• Extending APL to infinity. E. E. McDonnell and J. O. Shallit. (web).
• The story of 0÷0. J. L. F. De Kerf.
• Some geometrical consequences of complex APL. N. D. Thomson.
• Extended direct definition of APL functions. R. C. Metzger.
• Grammatical inference with APL. C. Witteveen.
• Milling machine by APL. R. Pinzani, F. Pippolini, and R. Spugnoli.
• The APL solution to a large planning problem. D. N. Owen and T. Talbot.
• APL and functional morphology. G. C. A. Elshould.
• Linguisting modelling with APL. H. Koppelaar.
• A recovery system for APL applications. J. T. Hardin and C. M. Norcutt.
• Base interactive De Donnees D'Aval section (BIDAS). A. Vaissiere.
• Base operations within relational data models. F. Schmidt and N. B. Theilgaard.
• LITSYS, a small scale literature system. E. M. van Ingen and J. S. Ploem.
• APL relational data base design aid. C. E. Mahood.
• APL in computer assisted instruction, a selecting mechanism. J. Spoelstra.
• Computer-aided learning: a time-sharing system versus a stand-alone computer. J. Moonen, H. van Dissel, and B. Vink.
• A natural blend of APL and high school mathematics topics. L. Alvord.
• Alternative addition algorithms in APL: inplications for education. H. A. Peelle.
• Multivariate data analysis in APL. P. Lewi.
• T.ES.I: an APL command language for exploratory analysis of pictorial data definition commnads, exploration commnads and graphical commnads to go through a redefinition and/or refinement steps. P. Brambilla, M. dell' Oca, and P. Mussio.
• Integrated data analysis and management. R. Erbe, R. Hartwig, H. Lehmann, G. Mueller, and U. Shauer.
• How modern is APL? W. K. Giloi.
• Using other programming languages to support APL. T. W. Cook.
• A group of input utility functions. M. W. Gardner and R. H. Swain.
• International standardization of APL. R. Tisserand.
• Construction of APL processors. A. J. Perlis.

1981

The 1981 APL conference was held in San Francisco, California from October 21 to 23. It featured eight invited talks in addition to 50 papers drawn from over 300 submissions, two panel discussions, tutorial lectures, and a poster display. Also notable was a performance of APL Blossom Time given by Larry Breed, Jim Brown, and others.

• A vision of probability and statistics using APL. Linda Alvord. [277].
• Text-editing and photocomposing APL publications. Arlene E. Azzarello. [278].
• The dynamic storage management for increasing a programming language power: The SIMULA lesson. Karel Babcicky. [279].
• A distributed file system in APL. Jean-Pierre Barasz. [280].
• Tensor and multilinear algebra. Sylvain H. Baron. [281].
• Adding and using structure in general arrays. J. Philip Benkard. [282].
• Representations for enclosed arrays. Robert Bernecky. [283].
• APL and the search for truth: A set of functions to play New Eleusis. Michael J.A. Berry. [284].
• An APL pattern-directed module for bidimensional data analysis. Silvana Bianchi, Piero Mussio, Anna Della Ventura, Anna Rampini, and Maurizio Dell’Oca. [285].
• The APL identity crisis. J. A. Brown and M. A. Jenkins. [286].
• Using an APL micro computer for distributive processing. Sandra L. Browne and Adrian Browne. [287].
• Hidden plane elimination and surface shading of polygons representing buildings using APL. David L. Cornell and Warren G. Julian. [288].
• Should APL be a declining language?. Michael F. C. Crick. [289].
• APL and Halstead’s theory of software metrics. Joseph L.F. De Kerf. [290].
• A regular expression pattern matching processor for APL. Mark R. Dempsey and Leslie H. Goldsmith. [291].
• A pictorial format function for patterning decorated numeric displays. Adin D. Falkoff. [292].
• Complex floor revisited. Doug Forkes. [293].
• An APL poisson solver. Ronald I. Frank. [294].
• Parsing and evaluation of APL with operators. M. P. Georgeff, I. Fris, and J. Kautsky. [295].
• QMOD: A system for automatically generating and solving analytical queueing network models. Leo H. Groner. [296].
• Graphical data structures in APL. Martin Hardwick. [297].
• AP19 - a shared variable terminal I/O interface for APL systems. Bruce J. Hartigan. [298].
• A function definition operator. Kenneth E. Iverson and Peter K. Wooster. [299].
• The use of APL as an executable formal language in economics demonstrated by an example. Wolfgang H. Janko. [300].
• A development system for testing array theory concepts. M. A. Jenkins. [301].
• APL in operating systems research. Greg Johnson. [302].
• Programming development control system. Erkki Juvonen. [303].
• Generic functions by nonstandard name scoping in APL. James T. Kajiya. [304].
• Generic programming: APL and Smalltalk. Alan C. Kay. [305].
• A structured APL approach to computer aided instruction. Wilbur R. LePage. [306].
• Teaching macroeconomics using APL. Stephen D. Lewis. [307].
• Beyond laminate: Generalizing creation of new dimensions in arrays and function action along them. Jim Lucas. [308].
• Predicting the profitability of life insurance products. Eugene R. Mannacio. [309].
• Compiling into APL. George R. Mayforth. [310].
• APL thinking finding array-oriented solutions. Robert C. Metzger. [311].
• Mesa from the perspective of a designer turned user. James G. Mitchell. [312].
• Namespaces semipermeable membranes for APL applications. Ronald C. Murray. [313].
• A portable APL language test generation and verification system. Charles G. Nylander. [314].
• The class concept in the Simula programming language. Jacob Palme and Mats Wallin. [315].
• Teaching a topic in cybernetics with APL: An introduction to neural net modelling. Howard A. Peelle. [316].
• AIDS, APL integrated-circuit design system. Paul Penfield. [317].
• Principal values and branch cuts in complex APL. Paul Penfield. [318].
• Is APL a programming language or isn’t it?. Alan J. Perlis. [319].
• Indexing and indexed replacement in APL. Roland H. Pesch. [320].
• Expert systems—a technology for intelligent assistance. Harry C. Reinstein. [321].
• Execute and its use. Will J. Roden and Garth H. Foster. [322].
• Convivial error recovery. Denis Samson and Yves Ouellet. [323].
• SETL-a very high level language oriented to software systems prototyping. Jack Schwartz. [324].
• Infinite arrays and diagonalization. J. O. Shallit. [325].
• Nested arrays, operators, and functions. Bob Smith. [326].
• Use of APL in operations research an interactive dynamic programming model. Moshe Sniedovich. [327].
• APL pi designing an APL type font. Joey K. Tuttle. [328].
• Generating design proposals with APL graphic functions. John W. Wade. [329].
• Compile time syntax analysis of APL programs. Zvi Weiss and Harry J. Saal. [330].
• World view from a satellite. Philip R. Westlake. [331].
• Improved sharing of APL workspaces and libraries. James G. Wheeler. [332].
• Progress on an ANSI standard for APL. Clark Wiedmann. [333].
• An APL mapping system. Anthony V. Williams and Stephen E. Winckelman. [334].
• TAGINE, an interactive tool for report generation. Colette Yazigi. [335].

1982

• Exception handling in APL. Dennis R. Adler. [336].
• Interactive design of neutron beam collimators using the Monte Carlo technique in APL. C. Bastian. [337].
• Nonpositional indexing for a relational data base. J. Philip Benkard. [338].
• APL and the relational model. J. Michael Blackford and Robert M. Taylor. [339].
• Extending APL: What more can a programmer ask for?. Dragan Bozinovic. [340].
• APL on a multiprocessor architecture. Norman Brenner. [341].
• APLNET, a local computer network. Daniel Brocklebank. [342].
• Understanding arrays. James A. Brown. [343].
• The hunting of the Snark. Philip R Chastney. [344].
• ADONIS a dynamic APL interactive package for multivariate analysis. Josiane Confais, Sylviane Bonnefous, and Jean Brenot. [345].
• Problem solving with APL using micro-computers. A D Crossley and H J Ward. [346].
• Desirable extensions to APL for handling numerical multidimensional arrays. Egon Dorrer. [347].
• FITTEN - an APL workspace for nonlinear regression. Lutz Edler and Jutta Berger. [348].
• Practicing on the CORE Graphics System. G. Faconti and P. Palamidese. [349].
• Semicolon-bracket notation: A hidden resource in APL. A. D. Falkoff. [350].
• Uses of APL in a manufacturing environment. Howard W. Gutzman and Edwardo Kellerman. [351].
• Experimental mathematics using APL and graphics. Charles Haspel and Alphonse Vasquez. [352].
• Adapting numerical algorithms to APL. Garry Helzer. [353].
• APL full screen editing and error handling. Raymond C. Hooker. [354].
• APL in education. Kenneth E. Iverson. [355].
• Practical uses of a model of APL. Kenneth E. Iverson and Arthur T. Whitney. [356] (web).
• The use of APL primitives and function domains to produce general APL solutions to problems involving discontinuities. Warren G. Julian. [357].
• The use and disuse of APL: An empirical study. Raymond Kanner. [358].
• Management of a large block-diagonal macro-economic model in APL. Eeva-Liisa Kaski. [359].
• NUMETH a user oriented programming system for interactive application of numerical methods. Klaus Kilberth. [360].
• Computer arithmetic and programming languages. Ulrich W. Kulisch. [361].
• Using APL in an Artificial Intelligence environment: A knowledge engineering system dealing with biographical data. Georges Lee, Ruddy Lelouche, Vincent Meissonnier, and Gian Piero Zarri. [362].
• An APL simulation of feedback systems. Wilbur R. LePage and Richard McFee. [363].
• Transparent files in APL (A Preliminary Proposal). Jim Lucas. [364].
• Extending Halstead’s software science for a more precise measure of APL. Ross A. Mauri and A. Harry Williams. [365].
• A self-defining dynamic data management system using multiple access methods. Normand R. Montour. [366].
• Rectangularly arranged collections of collections. Trenchard More. [367].
• Extending APL “optional arguments”. Richard L. Naugle and Joseph B. Schlam. [368].
• A technique for producing graphical presentations with instances of a unit symbol. Walter H. Niehoff. [369].
• A financial modeling language using Nested Arrays. Robert P. Noss. [370].
• Teaching a topic in psychology with APL: A cognitive information processing model. Howard A. Peelle. [371].
• Large arrays and files. Roland Pesch. [372].
• A conceptual framework for the design of Market Simulations. Girard C. Pessis. [373].
• Automated testing in APL—an application of exception handling. Jan F. Prins. [374].
• APL event / response programming. David A. Rabenhorst. [375].
• CPS - an APL conference planning system on a microcomputer. Lutz Richter and Hellfried Ciorga. [376].
• A survey of extensions to APL. Karl Fritz Ruehr. [377].
• Array diagrams and the Nial approach. Fl. Schmidt and M. A. Jenkins. [378].
• Eigenanalysis and polynomial root finding primitive functions. S. Schmidt, J. A. Brown, and M. A. Jenkins. [379].
• A programming environment for blind APL-programmers. Waltraud Schweikhardt. [380].
• Computational simplicial homology in APL. J. O. Shallit. [381].
• Interactive multilevel definition of APL functions. Moshe Sniedovich. [382].
• APL - a boon to budgeting. Beverly J. Spellman and M. Scott Downing. [383].
• Indexing infinite arrays: Non-finite mathematics in APL. R. W.W. Taylor. [384].
• An APL-guided tour through the elements of multi-dimensional geometry. Norman D. Thomson. [385].
• The impact of microcomputers on APL. Philip A. Van Cleave. [386].
• APL: A profitability language. William G. vonBerg. [387].
• The use of APL in a concurrent data flow environment. Michael N. Wakshull. [388].
• The application of an APL micro computer solving a commercial problem - a case study. H J Ward and P W Hurdley. [389].
• Design considerations of a micro-based APL. J. C. Wilson and T. A. Wilkinson. [390].
• A short-run forecasting model. Miklós G. Zilahi-Szabó. [391].
• A parser as a user-interface, driven by an enclosed array.. Michael Zippel. [392].

1983

• Teaching social studies concepts using concrete models expressed in APL. Tama Traberman. [393].
• APL learning bugs. Murray Eisenberg and Howard A. Peelle. [394].
• Increasing the use of APL. John W. Myrna. [395].
• Interactive circuit design program in APL. D. A. Zein, C. W. Ho, and A. J. Gruodis. [396].
• The engineering computer library (ENGLIB) an APL system for increased engineering productivity. Harold R. Ward. [397].
• An APL batch scheduler improves service and system management. Jeff Shrager and Lyle Hartman. [398].
• APL as a tool for multivariate statistics. Norman Thomson. [399].
• Interactive data analysis and statistical graphics in APL. Neil W. Polhemus. [400].
• APLDOT an APL programmer’s modeling language. Stephen R. Kruba. [401].
• TPLAN a table driven planning system. S. B. Jaffe. [402].
• TASO - an APL toolbox for financial planning. Tauno Ylinen and Pekka Lahti. [403].
• An APL-based multiple-key file system. Stephen Deerhake. [404].
• Extending a report generator written in APL. David Hirschberg. [405].
• Publications inventory control and distribution. Deborah R. Richardson. [406].
• A file system for VM-TOTAL/APL. R. Bruce Mann. [407].
• APL and I-D-S/II APL access to large databases. Bruce Frost. [408].
• Interfacing APL and SQL. Brian Hagenbuch and Martin Gardner. [409].
• Cooperating input and output stack processors. Cory F. Skutt. [410].
• Examples of event handling in APL2. Alan Graham. [411].
• Attached processors in APL. Karl Soop. [412].
• A.P. 1 APL.68000’s local auxiliary processor mechanism. A. Van Cleave. [413].
• Workspace interchange on microcomputers. L. J. Dickey. [414].
• Generalizing APL I/O. Cory F. Skutt. [415].
• Using graphs to analyze APL functions. Robert Metzger. [416].
• The perils of plenty - managing a large APL project. Jill Wade and Mary Vislay. [417].
• An inflation management system: SOLUTION-33T.M.. Mary Lou Fox. [418].
• Automatic programming of APL functions for screen management. Y. S. Chua and C. N. Winton. [419].
• A flexible full-screen applications development workspace utilizing APL syntax. David M. Weintraub. [420].
• A powerful but simple editor based on APL. Norman Brenner. [421].
• A microcomputer APL*PLUS system implementation. Phelps Gates. [422].
• An APL compiler for the UNIX timesharing system. Timothy A. Budd. [423].
• A performance comparison between an APL interpreter and compiler. Clark Wiedmann. [424].
• APL2 syntax: Is it really right to left?. James A. Brown. [425].
• APL syntax and semantics. Kenneth E. Iverson. [426] (web).
• Valence and precedence in APL extensions. J. Philip Benkard. [427].
• Merrily we roll along: Some aspects of?. J. O. Shallit. [428].
• Reflections on grades. J. Philip Benkard and John N. Seebe. [429].
• A comparison of reduction in APL with polyarity in LISP. David S. Touretzky. [430].
• Toward shared variable events: implications of ⎕SVE in APL2. John A. Gerth. [431].
• Extending APL for pattern matching. Norman Brenner. [432].
• APL function variants and system labels. David A. Rabenhorst. [433].
• Function and context. Stephen Taylor. [434].
• Designing and implementing an array theory incorporating abstract datatypes. James T. Kajiya. [435].
• APL standardization. L. A. Morrow. [436].

1984

• Frangere..decision support in many dimensions or..how to break the old spread sheet approach. Paul Barnetson. [437].
• A dyadic determinant function. Sylvain Baron. [438].
• An extension of relational database model to probabilistic data. Renzo Beltrame. [439].
• An APL interface to the open systems interconnection for large scale application systems. R. Beltrame, G. Faconti, and P. Palamidese. [440].
• Rank vs depth for array partitioning. J. Philip Benkard. [441].
• Syntactic experiments with arrays of functions and operators. J. Philip Benkard. [442].
• Function arrays. Robert Bernecky. [443].
• Shared functions and variables as an aid to applications design. Michael J.A. Berry. [444].
• Word, image and metaphor to name APL concepts in many tongues. Paul Berry, Gottfried Bach, Michel Bouchard, Margarete Buch, Sachiko Ikeuchi Berry, and Roland Pesch. [445].
• Editing APL objects with CMS XEDIT. Norman Brenner. [446].
• VLSI circuit design using APL with fortran subroutines. Norman Brenner. [447].
• Function assignment and arrays of functions. James A. Brown. [448].
• APL two by two-syntax analysis by pairwise reduction. J. D. Bunda and J. A. Gerth. [449].
• An APL system for interactive scientific-engineering graphics and data analysis. G. J. Burkland, P. Heidelberger, P. D. Welch, L. S.Y. Wu, and M. Schatzoff. [450].
• An example of the APL’s incursion in the medical world: The usefulness of this language for non computer scientist physicians. Jean Canet. [451].
• Guidelines for the APL entrepreneur. Robert R. DeCloss. [452].
• APL iconics. Maurizio S. Dell’Oca and Piero Mussio. [453].
• A high-performance environment for APL. John Delo and Sanford Friedman. [454].
• One man’s view of the ideal APL system. Adin D. Falkoff. [455].
• APL application development in a micro system environment. Jos Flury and Dirk Lankhorst. [456].
• APL approaches to time-phased financial modelling logic. Ralph L. Fox. [457].
• APL transmission path analysis for design of a local area network. A. A. Friedrich and R. D. Love. [458].
• Misnet—the APL management information system for communications network. Isaak Gilyutin. [459].
• Representation & combination of Boolean functions using APL. Eric Gullichsen. [460].
• Use of virus functions to provide a virtual APL interpreter under user control. J. B. Gunn. [461].
• Computational geometry with APL. Stig Gustafsson. [462].
• An APL approach to differential equations. Garry Helzer. [463].
• RIPO: An automated prototyping tool based on nested arrays. Laurle J. Hendres. [464].
• Information security issues in an APL application. Bill Hillman. [465].
• Using fullscreen-support and graphics in an end-user-friendly management information system. Conrad H. Hoesle. [466].
• APL editor features for productivity and quality. Timothy P. Holls. [467].
• APL programming: A psychological model. Raymond C. Hooker. [468].
• An operator calculus. Kenneth E. Iverson, Roland Pesch, and J. Henri Schueler. [469] (web).
• Proposal for a prototyping kit. Jan Jantzen. [470].
• Logic programming in APL. Robert Jernigan. [471].
• Application development and control system (ADACS). Rolf Körnemark. [472].
• An input-checking function for APL systems. Richard Levine. [473].
• Polyvalent functions, operators, strand notation and their precedence. Richard L. Naugle and Joseph B. Schlam. [474].
• Representing rubik’s cube in APL. Howard A. Peelle. [475].
• The impact of APL2 on teaching APL. Raymond P. Polivka. [476].
• APL curvilinear regression and associated problems. M. P. Racite and S. R. Dickstein. [477].
• A proposal for control structures in APL. Denis P. Samson. [478].
• A fast APL algorithm for logic minimization. Alfred A. Schwartz. [479].
• The future of programming—whither APL?. John R. Searle. [480].
• Using APL as a preprocessing selector from large VSAM files. Michael Simpson. [481].
• Can an APL workspace be used as a data base?. Karl Soop. [482].
• Exact nonparametrics in APL. Bernd Streitberg and Joachim Röhmel. [483].
• INFO-FRAGA, a user friendly query language for large files and data bases. Peter Söderström. [484].
• The IBM personal computer APL system. M. Tavera, M. Alfonseca, and J. Rojas. [485].
• The one tree (breaking out of the workspace). Stephen Taylor and Arthur Whitney. [486].
• Cultivating trees - an essay in APL2. N. D. Thomson. [487].
• Interactive flowcharting on a presentation graphics terminal. Gustav Tollet. [488].
• Serialization of SVP requests-a locking proposal for APL. Michael Van Der Meulen. [489].
• Practical guidelines for a user-friendly interface. Jill Wade. [490].
• Geometric transformations in APL. John W. Wade. [491].
• Using APL to understand bit-slice microprocessors. J. Welford. [492].
• On representation and manipulation of mathematical formulas using general array data structure: IFORP (interactive formula processor). Kiyotaka Yasui. [493].

1985

• Array oriented exception handling: a proposal for dealing with “invalid” data. Jim Lucas. [494].
• An SQL interface for VS APL. Casey Bley. [495].
• The APL 90 project: new directions in APL interpreters technology. Jean-Jacques Girardot. [496].
• Freestyle graphics with APL. Aale Roos and Heikki Laitonen. [497].
• Dataflow analysis in APL. Timothy A. Budd. [498].
• Compiling APL for parallel execution on an FFP machine. Alexis Koster. [499].
• The graphical kernal system—an opportunity for APL. Richard Nabavi. [500].
• APL and GDDM (tutorial). Mary Lou Fox and Patrick Parks. [501].
• Teaching APL2. Raymond Polivka. [502].
• Design of APL (tutorial). John Gerth. [503].
• System commands: an APL backwater revisited. Michael J. A. Berry. [504].
• An integrated business application architecture. Wei-Tih Cheng. [505].
• Software publishing and the software developer. Philip Evans. [506].
• Integrating ordinary type and many languages with the APL alphabet and keyboard. Paul Berry. [507].
• Efficiency in the APL environment—a full arsenal for attacking CPU hogs. Clark Wiedmann. [508].
• APL teaching bugs. Howard A. Peelle and Murray Eisenberg. [509].
• APL and robotics. A. Martin Euredjian. [510].
• Artificial intelligence development aids (AIDA). Gary Sullivan and Kenneth Fordyce. [511].
• Improving APL performance with custom written auxiliary processors. Andrew K. Dickey. [512].
• AMS: an APL management system. John W. Burgeson and Robert G. Germain. [513].
• Control of structure and evaluation. J. Philip Benkard. [514].
• Corporate application of APL—case studies (panel). Eric J. Baelen, Bion B. Bierer, Stephen B. Jaffe, Anthony R. Lantz, and Lynne C. Shaw. [515].
• APL graphics products (panel). Carolyn B. Catlin, Linda Furrow, Clif Kranish, Neil W. Polhemus, and Jonathan R. Strong. [516].
• Writing interpreters (panel). Robert Bernecky, Geno Coschi, James Ryan, Bob Smith, Philip A. Van Cleave, and James Wheeler. [517].
• APLIM—applied linear interactive models. J. I. Ansell and A. M. Sykes. [518].
• Extended shared-variable sessions. Karl Soop and Roderic A. Davis. [519].
• Using dimensions to represent attributes. Dan M. King. [520].
• Design: a financial modelling system. Fred Appleyard and Roger Hui. [521].
• Structural experiments with arrays of functions. J. Philip Benkard. [522].
• XPL: an expert systems framework in APL. Robert Bittlestone. [523].
• Operators for program control. Edward V. Eusebi. [524].
• Operators for recursion. Edward V. Eusebi. [525].
• The use of APL versus other languages—a six year trend analysis. John W. Myrna and Peter G. DiChellis. [526].
• Tadpoles and frogs: metamorphosis in APL code. Thomas J. Pritchard. [527].
• Lotus 1-2-3 for mainframes (bringing a product to market). Kevin R. Weaver. [528].
• An APL database system for R&D laboratories. H. A. Hartung. [529].
• Mortgage insurance: a view from the APL terminal. Chester C. Foster and Thomas N. Herzog. [530].
• Mathematics education through the perspective of rationalized APL. Linda Alvord. [531].
• An introduction to STSC’s APL compiler. Jim Weigang. [532].
• A group of APL functions for computer-assisted instruction. Vin Grannell. [533].
• The intelligent approach to teaching arithmetic. Irvin R. Whiteman. [534].
• N-dimensional geometry using APL2. Charles Haspel and Alphonse Thomas Vasquez. [535].
• An APL production environment. Gösta Olavi. [536].
• Inside the APL2 workspace. James A. Brown. [537].
• APLGRAPH—how to develop graphics software without really trying. Tauno Ylinen. [538].
• An APL based relational data management language using SYSTEM R as data server. F. Antonacci and P. Dell’Orco. [539].
• ≅USER: the user-definable system function in Data General’s AOS/VS APL. Jan-Willem Neurdenburg and Phil S. Schwarz. [540].
• MEDCAT: an APL program for medical diagnosis, consultation, and teaching. W. D. Hagamen, Martin Gardy, Gregory Bell, Edwin Rekosh, and Steven Zatz. [541].
• Commercial applications (panel). Kevin R. Weaver, Thomas G. Atkins, Michael L. Haas, John A. Bunyan, Vess E. Irvine, and Douglas W. Taylor. [542].
• Promoting APL (panel). Patricia A. Buteux, Edward M. Cherlin, Percy Feiner, Jim Lucas, Eugene McDonnell, Michael Sunday, and Sheryl Winton. [543].
• Developing auxiliary processors (tutorial). Andrew K. Dickey. [544].
• APL microcomputer products (panel). John D. Burger, John W. Myrna, Richard S. Paulson, David Saunders, Richard M. Smith, Philip A. Van Cleave, and John C. Wilson. [545].
• APL programming standards (panel). Bion Bierer, Joe Heise, and Eugene Mannacio. [546].

1986

• Style and literacy in APL. Michael J. Berry and Roland H. Pesch. [547].
• Manufacturing resource planning on a PC local area network. H. Clark Kee and Roy L. Post. [548].
• Empty frames in sharp APL. Roland H. Pesch. [549] (web).
• A notation for manipulating arrays of operations. David J. Landaeta. [550].
• LAPLAN—A corporate planning model for Laura Ashley. Adam Dakin. [551].
• Development of a portable software product for library automation. A. M. Barnaud, Y. Le Borgne, and B. Mailhol. [552].
• APL2—A mathematician’s delight. Norman Thomson. [553].
• The scope of APL in nuclear measurements. C. Bastian. [554].
• From tensor and suffix notation to APL. Egon Dorrer. [555].
• APL in quality business management. Terence J. McKee. [556].
• Quaternions and homogeneous co-ordinates. Stig Gustafsson. [557].
• Modelling the arithmetic of statistical distributions. Leo H. Groner and Janice H. Cook. [558].
• APL graphics representation and analysis of space-based observations. Jack Rudd. [559].
• Bringing graphic dialogues to APL. Karl Soop. [560].
• IOTA3: the integration of Lotus spreadsheets and APL. John R. Searle. [561].
• Extending worksheet modelling software with expert system technology. Gerald A. Sullivan and Kenneth J. Fordyce. [562].
• Topics for a second course in APL. Stephen B. Jaffe. [563].
• Machine-oriented languages in the APL environment. Jim Weigang. [564].
• Medium term forecasts of half-hourly power demand. J. E. McGowan and D. J. Parker. [565].
• Compiling optimized array operations at run-time. Thomas W. Christopher and Ralph W. Wallace. [566].
• An APL/370 compiler and some performance comparisons with APL interpreter and FORTRAN. Wai-Mee Ching. [567].
• DELIS: A decision support system generator for frequency data. Richard W. Butterworth and Robert A. Stephan. [568].
• A generalised data base interface for APL. Robert Jernigan and Arie Eisner. [569].
• APL compilation and interpretation by translating to F83VEC. Richard Naugle. [570].
• Idioms and problem solving techniques in APL2. Alan Graham. [571].
• APL procedures (user defined operators, functions and token strings). Robert Hodgkinson. [572].
• Field results with the APL compiler. Clark Wiedmann. [573].
• Open fullscreen systems. Martin Gfeller and Monika Stengl. [574].
• Analysis of function applications in deep arrays. J. Philip Benkard. [575].
• The integration of relational database algebra into APL. David Livingstone. [576].
• APL: A prototyping language. Robert Bernecky. [577].
• Checkpoint—Restart for APL applications. Otway O. Pardee. [578].
• Assertive comments in APL programming. David M. Weintraub. [579].
• APL as a prototyping language: case study of a compiler development project. Matsuki Yoshino. [580].
• Increasing productivity with ISPF/APL2. Loren B. Mayhew. [581].
• Automated application programming environment. Yap S. Chua and Charles N. Winton. [582].
• Writing multi-user applications in APL2. James A. Brown. [583].
• A logic programming tool for qualitative system design. Gert L. Moller. [584].
• Extending APL to logic programming. M. Alfonseca and M. J. Tobar. [585].
• Generalised arrays and shortest path problems. Claudio Sandi. [586].
• Logic programming in APL2. James A. Brown, Janice H. Cook, Leo H. Groner, and Ed Eusebi. [587].
• A perfect square root routine. E. E. McDonnell. [588] (web).
• APL2 and AI: a study of search. Ed Eusebi and James A. Brown. [589].
• Typesetting APL using a Macintosh. John E. Howland. [590].
• TEXT: Publication-quality characters come to APL graphics. Ian Feldberg. [591].
• LOGOS: An APL programming environment. David B. Allen, Leslie H. Goldsmith, Mark R. Dempsey, and Kevin L. Harrell. [592].
• Japanese APL language system on IBM Multistation 5550. M. Udo, Y. Akimoto, S. Kaneko, T. Sanuki, and M. Alfonseca. [593].

1987

• A three dimensional wire frame graphics system. Uday G. Gujar. [594].
• Practical uses of operators in Sharp APL/HP. Robert Hodgkinson. [595].
• Control system development tools. Scott Kimbrough. [596].
• Why APL2: a discussion of design principles. James A. Brown. [597].
• The role of APL in a technical language as illustrated by a modest battle management program. John C. McInturff. [598].
• Programming considerations for documentation and maintenance. Stephen C. Fleming. [599].
• Some uses of { and }. Roger Hui. [600] (web).
• APL87. Kenneth E. Iverson. [601] (web).
• Teaching theory of computation at the junior level. Y. S. Chua and C. N. Winton. [602].
• A minicomputer network management monitoring and analysis system using APL. Fred A. Gross and James C. Taylor. [603].
• APL2—a very superior Fortran. Norman Thomson. [604].
• A model for teaching APL: moving into the fast lane. Tama Traberman. [605].
• Application screen management: an APL2 approach. Stephen Deerhake. [606].
• On APL software for credibility theory. M. J. Goovaerts. [607].
• An object oriented extension to APL. Jean Jacques Girardot and Sega Sako. [608].
• System development methodology using LOGOS. David B. Allen, Mark R. Dempsey, and Leslie H. Goldsmith. [609].
• An APL compiler: The SOFREMI-AGL compiler, a tool to produce low-cost efficient software. Alain Guillon. [610].
• Trees as nested arrays and the use of underdisclose. G. C. Nauta. [611].
• Implementation of an APL—based spreadsheet manager. Tom Puckett. [612].
• Server networks communicating via inter-user shared variables. Lawrence Zeidner. [613].
• Techniques for extracting statistical data from free-form text using APL. L. Owen Hill and David A. Zein. [614].
• Boolean array structures for a rule-based forward chaining inference engine. Kenneth Fordyce and Gerald Sullivan. [615].
• The APL:9SPlus:2E System for the Macintosh: an overview. Edward R. Myers. [616].
• Component file systems and the APL standard. Robert Bernecky and Maxine Hersch. [617].
• Automatic generation of graphs from free-form text using APL. L. Owen Hill and David A. Zein. [618].
• Managing APL public code for an in-house APL system (before and after LOGOS). D. F. Stoneburner. [619].
• APL2 implementations of unification. James A. Brown and Ramiro Guerreiro. [620].
• APL extensions—a users view. Maurice H. Jordan. [621].
• A full-screen front end for GRAPHPAK. J. M. Cass. [622].
• Replicate each, anyone?. J. Philip Benkard. [623].
• APL function definition notation. John Bunda. [624].
• FSM—a fullscreen manager. R. J. Busman. [625].
• A survival strategy for APL. Dick Bowman. [626].
• APL to Ada translator. Jack G. Rudd and Eric M. Klementis. [627].
• A CAD system in APL. Uday G. Gujar and Joseph W. P. So. [628].
• Screen management in the “real world”. Edmund W. Stawick. [629].
• Development of APL—based distributed processing systems. Steven I. Promisel. [630].
• TSIOPAK—a proposal for a new Sharp APL file system. Carlos G. Leon. [631].
• An integrated microprogram development methodology based on APL. Jan W. M. Jacobs and Roger J. H. Hacking. [632].
• Implications of APL2 grammar. J. Philip Benkard. [633].
• Using the LOGOS programming environment—a case history. Steve Chapman. [634].
• Functional programming, the IEEE floating point standard and APL. Terence J. Reed. [635].
• A system for compiling fonts. John E. Howland. [636].
• Solutions to logic problems in APL2. James A. Brown and Manuel Alfonseca. [637].
• An APL idiom inventory. Howard A. Peell. [638].
• A second generation DOMINO for statisticians. Alan Sykes. [639].
• Infinite loops and how to create them. John R. Searle. [640].
• Inductive reasoning from relations. Edward V. Eusebi. [641].
• A proposal for blocks and exits in APL. Jim P. Fiegenschue. [642].
• AUTOMAT, an end-user approach in handling applications as multi-dimensional arrays. Jean Marie Monnier. [643].
• The FinnAPL keyword editor. Juhani Sandberg, Olli Paavola, and Tauno Ylinen. [644].
• How graphics could be simplified in APL. Gerard A. Langlet. [645].
• A case study in the design of an APL application: REGGPAK, an econometrics regression package. D. J. Parker and M. E. Elliott. [646].
• Recapturing the high ground—use of APL in decision tree modelling. Dick Bowman. [647].
• APL thinking: examples. Murray Eisenberg and Howard A. Peelle. [648].
• The syntax of APL, an old approach revisited. Jean Jacques Girardot and Florence Rollin. [649].
• Investigation into the efficiency of using APL for the programming of an inference machine. Wolfgang H. Janko. [650].
• APL—compilation-where does the time come from?. Graham C. Driscoll and Donald L. Orth. [651].
• How to win the respect and admiration of the rest of the DP world. Kim S. Andreasen, Svend Elkjaer Frandsen, and Morten Kromberg. [652].
• Designing APL2 programs for unification. James A. Brown and Ramiro Guerreiro. [653].
• Design of a new user interface for APL. John E. Howland. [654].
• OPERA: options price evaluation and risk analysis system. Barry Bogart. [655].
• Sherlock Holmes: the mystery of the vanishing variable. Roger Willink. [656].
• Typesetting APL using TROFF. Leroy J. Dickey. [657].
• Using other languages to supplement APL. Donald W. Soule. [658].

1988

• APL2-a RISC business. M. Alfonseca and D. Selby. [659].
• Parametric Fourier image characterization toolkit. J. R. F. Alonso. [660].
• An interactive simulation modeling system: DYNAGRAPH for multi-period planning on an APL spreadsheet. T. Aonuma. [661].
• Symmetries of the firing squad sychronization problem revealed in a nested array. J. P. Benkard. [662].
• Some APL2 programming examples using nested arrays. J. P. Benkard. [663].
• An introduction to function rank. R. Bernecky. [664].
• An APL2 description of the IBM 3090 vector facility. J. A. Brown. [665].
• APL object manager. B. Bykerk. [666].
• I-APL: A portable ISO APL in under 25K. P. Chapman. [667].
• APL in a development environment. L. O. Clayton. [668].
• Application-sol  interaction: an APL2 approach. S. Deerhake. [669].
• High powers of matrices. L. J. Dickey. [670].
• Statistics loves APL. J. B. Douglas. [671].
• APL: The language of science and management. A. Eisner, S. M. Yionoulis, J. A. Platt, and R. Jernigan. [672].
• Computer vision and its application to APL. I. Feldberg. [673].
• APL2 implementation of numerical asset pricing models. W. Foote, J. Kraemer, and G. Foster. [674].
• Efficient evaluation of the area under the normal curve. G. Foster, J. Kraemer, and W. Foote. [675].
• Flexi-View: a multi-dimensional data modeling system. E. S. Friis and J. A. Goldberg. [676].
• Indexing and merging in APL. J. A. Gerth and D. L. Orth. [677].
• From a functional point of view: a framework for extensions to APL. M. Gfeller. [678].
• Parts of arrays-an introduction. M. Gfeller. [679].
• APL and finite elements for solving convection-diffusion problems, with examples from gas bearing design. F. Hendriks. [680].
• The use of APL.68000 access to the Macintosh quickdraw system for the productio n of shadows cast by buildings. W. G. Julian. [681].
• Comparative analysis of LISP and APL2. A. Kaneko. [682].
• An experimental facility for cooperative processing in APL. S. Kaneko. [683].
• APL and SAS in co-operation. E. Karjala. [684].
• APL applied in music theory. M. Kassler. [685].
• APL graphics for learning mathematics. M. Kikkawa. [686].
• The theory of function arrays. D. Landaeta. [687].
• Incremental systems development-a case study. P. Landherr. [688].
• Making APL cheap-Saving time and money in APL. J. Lucas. [689].
• Life: Nasty, brutish, and short. E. E. McDonnell. [690] (web).
• EXAPL (Expert System Based on APL) and its application to chemical analysis. T. Nishikawa. [691].
• Achievement certificates from graphics environment. T. M. Olsen. [692].
• Iterative scaling of marks using APL-a case study. P. Petocz. [693].
• Network shared variable processor. R. L. Potyok. [694].
• The compact display of arbitrary nested arrays. D. A. Rabenhorst. [695].
• Scope and access classes in APL. M. Rys. [696].
• Casual management of large computer systems with APL programs. Charles A. Schulz. [697].
• Windows and pop-up menus in application design. A. Smith. [698].
• APL graphics and the associative machine. K. Soop. [699].
• Issues in data base management for APL2. R. D. Stockbridge, A. Eisner, and R. Jernigan. [700].
• Innovation of decision support system-matplan based on structure matrix supported by APL. T. Toyama and M. Yauda. [701].
• APL object transfer in a multi-APL site. H. F. van Eggelen. [702].
• APL2 and the CMS system: Exploiting the APL2/REXX connection. D. M. Weintraub. [703].
• Arrays of objects in rationalized APL. Andreas Werder. [704].

1989

• APL and PS/2: the language, the system, the peripherals. M. Alfonseca and D. A. Selby. [705].
• Object oriented programming in APL2. Manuel Alfonseca. [706].
• Discrete simulation by APL-GPSS: the best of two worlds. M. v. Baaren, F. H. D. v. Batenburg, and H. P. T. v. d. Star. [707].
• User defined data types in APL2. J. P. Benkard and J. A. Brown. [708].
• What is an argument?. H. C. Bertuccelli. [709].
• APL and GDDM - a high performance toolkit. D. Bowman. [710].
• Neural network model of serial learning. H. A. Broadbent and J. Lucas. [711].
• Understanding selective assignment. J. A. Brown and B. Hawks. [712].
• APL at the crossroads. R. Brown. [713].
• Workspace `Maze’. A. Camacho. [714].
• An empirical study of the performance of the APL370 compiler. W.-M. Ching, R. Nelson, and N. Shi. [715].
• A simulation tool for teaching CPU design and microprogramming concepts. Y. S. Chua and C. Winton. [716].
• High productivity techniques for large APL system. D. Cook. [717].
• YSM: a full-screen manager for Dyalog APL. S. D. Curtin and J. Scholes. [718].
• APL as a tool of research for the mathematical scientist. E. J. Danial. [719].
• APL on the factory floor. D. Eastwood. [720].
• Implementation of predicate logic in APL2. U. Engelmann, Th. Gerneth, and H. P. Meinzer. [721].
• APL2 implementation of an interest rate volatility model. W. G. Foote and J. Kraemer. [722].
• A fusion of Lotus 1-2-3 and APL2. E. Friis. [723].
• An APL-tutoring adventure game. A. Geyer-Schulz, A. Taudes, and J. Mitlöhner. [724].
• A future APL: examples and problems. M. Gfeffer. [725].
• Object oriented programming in AIDA APL. M. Gfeller. [726].
• A planning language (a PLanguage). T. Gilb. [727].
• APLO: a simple modern APL. A. Graham. [728].
• Processing natural language syntactic and semantic mechanisms. W. Hagamen, P. C. Berry, K. E. Iverson, and J. C. Weber. [729].
• Opportunities for system and user features in a new APL interpreter. R. F. Hobson, J. D. Hoskin, and R. W. Spilsbury. [730].
• Phrasal forms. E. E. McDonnell and K. E. Iverson. [731] (web).
• Inference planning using digraphs and Boolean arrays. J. Jantzen. [732].
• APL for music. S. Jordan. [733].
• The benefits and advantages of APL. D. Julio and J. Mosland. [734].
• The structure and content of APL data. D. Landaeta. [735].
• Data typing in APL. D. Livingstone and H. Gharib. [736].
• Techniques for avoiding conditional execute in APL2. S. M. Mansour. [737].
• Expressing qualified logic in APL. J. C. McInturff. [738].
• Actuarial and financial calculations with base value (⊥). D. Michelson. [739].
• APL windowing systems - where next?. R. Nabavi. [740].
• An APL approach to differential calculus yields a powerful tool. R. D. Neidinger. [741].
• Thermochemical prediction program aided with EXAPL and APL2 data structure. Toshio Nishikawa and Ichiro Ogasawara. [742].
• APL as a tool for computations in growth studies. T. Nummi. [743].
• An expert system in chemical synthesis written in APL2/PC. P. Rodriguez, J. Rojas, M. Alfonseca, and J. I. Burgos. [744].
• Astrophysical APL - diamonds in the sky. G. Schneider, P. Paluzzi, and J. Webb. [745].
• Analysis of robot manipulators. R. G. Selfridge. [746].
• Making APL error messages kinder and gentler. W. J. Shaw. [747].
• Reflections on teaching APL to eighth graders. K. Sternberg. [748].
• An on-line help facility for APL2. J. Sullivan. [749].
• APL descriptions of functional building blocks for connectionist computer models. A. Surkan. [750].
• Enhancing XEDIT as a an APL editor. R. Swain. [751].
• Using APL2 in statistics. A. M. Sykes and A. G. Hawkes. [752].
• A paediatric management information system in APL. C. M. Sykes and A. M. Sykes. [753].
• Generic binary trees in APL2. N. Thomson. [754].
• APL in the workstation environment. J. R. Turner. [755].
• Observations on flight behavior in the butterfly. C. Waters. [756].
• Measure productivity: use a generally accepted metric. K. R. Weaver. [757].
• APL problem-solving (tutorial session): a tutorial. Murray Eisenberg and Howard Peelle. [758].
• Profiling, performance, and perfection (tutorial session). Robert Bernecky. [759] (pdf).
• APL2 and SQL (tutorial session): a tutorial. Nancy Wheeler. [760].
• Performance enhancers (tutorial session). Eric Baelen, Kevin Weaver, Roy Sykes, and Robert Lauer. [761].
• Exchanging APL workspaces (tutorial session). Harry Bertuccelli. [762].
• Desktop publishing or when cutting and pasting become a drag (tutorial session). Pamela Baron and James Kraemer. [763].
• Using APL for computer graphics notation (tutorial session). Judson Rosebush. [764].

1990s

1990

• The A+ programming language, a different APL. Jean-Jacques Girardot. [765].
• An APL-simulator of non-Von Neumann computer architectures. Andreas Geyer-Schulz, Johann Mitlöhner, and Alfred Taudes. [766].
• SRS service report system. Jan Ahlqvist. [767].
• Neural networks in APL. Manuel Alfonseca. [768].
• Object oriented programming, tutorial. Manuel Alfonseca. [769].
• Integrating APL with symbol manipulation, numerical software and graphics. Heikki Apiola and Pirkka Peltola. [770].
• Conscientious programming using PMA. Guy Barker, Douglas J. Keenan, and Herman van Loon. [771].
• Nonce functions. J. Philip Benkard. [772].
• ACORN: APL to C on real numbers. Robert Bernecky, Charles Brenner, Stephen B. Jaffe, and George P. Moeckel. [773] (download).
• Definition of image interpretation strategies in APL. P. Bottoni, P. Mussio, and M. Protti. [774].
• Preliminary mesh checking for structural analysis. Renato Capra. [775].
• APL trivia. Edward Cherlin. [776].
• Automatic parallelization of APL-style programs. Wai-Mee Ching. [777].
• Analytic response time model for distributed systems. Janice H. Cook and Leo H. Groner. [778].
• APL as the foundation for a universal computer language. Stephen W. Dunwell. [779].
• Technical support program for APL related question. Don Erickson. [780].
• A structured approach to analysis and design of complex systems. F. Evans and J. Jantzen. [781].
• Angiogram analysis in APL: a case study. Ian Feldberg. [782].
• APL2 analysis and design of mortgage backed securities. William G. Foote and Pamela J. Baron. [783].
• Editing and debugging with Windows and a mouse. Garth H. Foster, Abdelatif Elgouri, and Franklin Liu. [784].
• Color APL beautiful!. Ralph L. Fox. [785].
• Musical syntactic and semantic structures in APL2. Erik S. Friis and Stanley Jordan. [786].
• Arrays and references. Jean-Jacques Girardot. [787].
• Markov processes in APL. Alan G. Hawkes. [788].
• Sparse matrix technology tools in APL. Ferdinand Hendriks and Wai-Mee Ching. [789].
• APL\?. Roger K. W. Hui, Kenneth E. Iverson, E. E. McDonnell, and Arthur T. Whitney. [790] (web).
• APL for economic and management control in KTAS. Torben Iversen. [791].
• End-user KESSU. Eeva-Liisa Kaski. [792].
• The family of Soviet APL systems. Andrew V. Kondrashev. [793].
• An application development platform. Morten Kromberg and Martin Gfeller. [794].
• The travelling salesman problem, revisited with APL. Gérard A. Langlet. [795].
• Desktop publishing on the mainframe: integrating APL2 and Ventura Publisher. Timo Laurmaa. [796].
• Implementing the recursive APL code for dynamic programming. Edward Y. H. Lin and Dennis L. Bricker. [797].
• Programming ecology or APL and the world at large. Jim Lucas. [798].
• DEMOS—a PC-system for population projections for small areas. Sven Gunnar Lönn. [799].
• An insurance simulation model. Ole M. Meyer. [800].
• Algorithm alterable models and APL. Alexey L. Miroshnikov. [801].
• An array-theoretic look beyond APL2 and Nial. Trenchard More. [802].
• Multi-axis NC postprocessor for machining centers. Thomas M. Olsen. [803].
• Object oriented database using frames in second generation APL. Panagiotis Pantziarka. [804].
• Reading to write. Raymond P. Polivka. [805].
• IBM system/370 channel programming using APL. Thomas J. Pritchard. [806].
• Managing a diamond jewelry manufacturing business using APL. Steven I. Promisel and James V. Merrill. [807].
• A preferable look—APL in window-based environments. Ursula Recker and Michael Rys. [808].
• Toward a common prototyping language. Jack G. Rudd and James A. Brown. [809].
• Object-oriented programming of X Window System graphical user interfaces. William A. Rutiser. [810].
• A parallel APL machine. Jügen Sauermann. [811].
• Writing applications for uniform operation on a mainframe or PC: a metric conversion program. Charles A. Schulz. [812].
• Structured expert system design. D. Smellie and F. Evans. [813].
• Some uses of truncated Boolean vectors in analysis. Howard J. Smith. [814].
• What’s ahead for 2000 A.D.?. Howard J. Smith. [815].
• Stability in a sea of change. Danald Soule. [816].
• A shading approach to non-convex clipping. Thomas L. Springall and Gustav Tollet. [817].
• LYYTI—integrated design and control system. Timo Teileri and Toivo Olkkola. [818].
• APLELEGANCE—the art of staying within one’s depth. Norman Thomson. [819].
• FRESH, an expert system design tool on APL2. J. W. B. Vermeulen and E. R. K. Spoor. [820].
• APL2OS: design considerations for a nested array file system. David M. Weintraub. [821].
• Design and implementation of the interface to compiled languages in APL*PLUS II. James G. Wheeler. [822].
• Very high quality user interfaces and fast data filing using a PC. Jonny Österman. [823].

1991

• Genetic algorithms. Manuel Alfonseca. [824].
• A dance of rounds. J. Phillip Benkhard. [825].
• Extending structure, type, and expression in APL2. J. Phillip Benkhard. [826].
• Gerunds and representations. Robert Bernecky and Roger K. W. Hui. [827] (download).
• APL technology of computer simulation. A. Yu Boozin and I. G. Pospelov. [828].
• An APL rule-based system architecture for image interpretation strategies. P. Bottoni, M. Protti, and P. Mussio. [829].
• Designing a Kanban manufacturing system using the server network generator (SNG) CASE tool. A. Bouchentouf-Idriss and L. Zeidner. [830].
• An N-dimensional data structure in support of electronic data interchange (EDI) translation. Georges Brigham and Edward Shaw. [831].
• Compiling APL for parallel and vector execution. Timothy A. Budd and Rajeev K. Pandey. [832].
• Pure functions in APL and J. Edward Cherlin. [833].
• DSS structure and algorithmic transparency in APL. W. E. Cundiff. [834].
• An interactive data analysis system developed under APL. Peter I. Day. [835].
• AP 527: an ORACLE SQL—APL2/PC auxiliary processor. Stephen Deerhake. [836].
• Notes on C programming for APL programmers. Stephen Deerhake. [837].
• Programming for events. David S. Eastwood. [838].
• How to manage large APL projects: a user interface management system approach. Richard R. N. Eller. [839].
• Calling APL2 from COBOL. Don Erickson. [840].
• Relating number of processing elements in a sparse distributed memory model to learning rate and generalization. Richard M. Evans and Alvin J. Surkan. [841].
• Using boolean of integer arrays to analyze networks. Kenneth Fordyce, Mario Morreale, Jan Jantzen, and Gerald Sullivan. [842].
• APL as an embedded language: the ultimate application?. Jean Jacques Girardot. [843].
• Application of nested arrays to databases for engineering design. Yehonathan Hazony. [844].
• Tacit definition. Roger K. W. Hui, Kenneth E. Iverson, and Eugene E. McDonnell. [845] (web).
• Building an APL2 X-Windows interface for VM and AIX with a general APL2-to-C interface. John R. Jensen and Kirk A. Beaty. [846].
• CATS: computer aided testing of software. Maurice Jordan. [847].
• On performance and space usage improvements for parallelized compiled APL code. Dz-ching Ju, Wai-Mee Ching, and Chuan-lin Wu. [848].
• Psycho-biographical analysis with APL. Andrew V. Kondrashev and Alexander A. Kronik. [849].
• Forecasting system of an employment pension scheme. Timo Korpela and Bo Lundqvist. [850].
• The dual structure of ordered trees. Gérard A. Langlet. [851].
• Mastering J. Donald B. McIntyre. [852].
• A0 system: APL in construction planning. Alexei I. Miroshnikov. [853].
• The Boston University Manufacturing Expert System (BUMES): an APL-based CASE application. T. Shojaie, L. Zeidner, S. Sadri, and Y. Hazony. [854].
• Nuclear power plant diagnostics in APL. Alexander O. Skomorokhov. [855].
• Supply-chain management at Rowntree: critical success factors for APL. Adrian Smith. [856].
• APLITDS: an APL development system. Carlo Alberto Spinicci. [857].
• Automatic synthesis of the inverses of APL functions. Alvin J. Surkan. [858].
• Automated SQL documentation using APL2. Rexford H. Swain. [859].
• L-one-two-three (L1:..L2:..L3:) considered harmful. F. H. D. van Batenburg. [860].
• The user command processor. Jim Weigang. [861].
• Comparison of the functional power of APL2 and FORTRAN 90. Robert G. Willhoft. [862].
• Assembler utility functions for APL2/PC. Tauno Ylinen. [863].
• The server network generator (SNG): a CASE tool for distributed cooperative processing. L. E. Zeidner. [864].
• Toward a lexicon of musical APL2 phrases (invited). Stanley Jordan and Erik S. Frils. [865].

1992

• Object oriented graphics in APL2. Manuel Alfonseca. [866].
• Nested arrays and operators: some issues in depth. J. Philip Benkard. [867].
• Compiler tools in APL. Robert Bernecky and Gert Osterburg. [868] (pdf).
• APL2 implementation of cross-system shared variables. James A. Brown and Erik Kane. [869].
• 3D layout manipulation functions with a glance to optimization problems. Renato Capra. [870].
• Globally convergent polynomial iterative zero-finding using APL. Tien Chi Chen. [871].
• Distributed computing with APL. Andreas Geyer-Schulz and Thomas Kolarik. [872].
• Walks into the APL design space. Martin Gfeller. [873].
• The CTalk programming language: a strategic evolution of APL. Jean-Jacques Girardot. [874].
• An interactive approach for extending IEEE arithmetic: auxiliary processor AP87. Willi Hahn and Karlheinz Mohr. [875].
• An object-oriented APL2 expert. Evan Jennings. [876].
• Left to its own devices, APL plots on the bus. Curtis A. Jones. [877].
• Writing Macintosh “applications” in APL. Warren G. Julian. [878].
• Towards the ultimate APL-TOE. Gérard A. Langlet. [879].
• Cannibals and missionaries. Ruby Lim. [880].
• Multiple choice programming: an APL approach. Edward Y. H. Lin. [881].
• Porting APL-programs via ASCII-transliteration. Johann Mitlöhner. [882].
• Using SCCS to manage APL2 development projects. John M. Mizel. [883].
• Differential equations are recurrence relations in APL. Richard D. Neidinger. [884].
• APL as a tool for scientific forecasting. Andrew L. Pakhomov, Valery F. Kalinin, Boris A. Makeev, and Alexandra V. Zueva. [885].
• An APL2 tool box investigating Schwarz methods. Christoph Pospiech. [886].
• A multi-national sales planning system in APL. Steven I. Promisel. [887].
• Do Russian children like APL2?. Alexander O. Skomorokhov. [888].
• Neural networks in J. Alexei N. Skurihin. [889].
• Jogging with APL along the shortest path. Moshe Sneidovich and Suzanne Findlay. [890].
• Challenging the mathematics curriculum. Walter G. Spunde. [891].
• WSDM: Weighted sparse distributed memory prototype expressed in APL. Alvin J. Surkan. [892].
• Some proposals for APL2 specification of statistical algorithms. Norman Thompson. [893].
• A Be´zier curve builder implemented in APL2. Gustav Tollet and Peter M. Harrison. [894].
• Porting and optimising star: a case study of suffering and surfacing. F. H. D. van Batenburg, V. Bos, J. J. M. Riethoven, J. P. Abrahams, and C. Pley. [895].
• Matrix operations over integral domains using nested APL. Robert G. Willhoft. [896].
• Petri-net evaluation using APL2. Robert G. Willhoft. [897].
• EZHONE: a perfect application for APL2 name association. Scott Williams, Howard Smith, and Ray Parnaby. [898].

1993

• ARDA: expert system for reliability data analysis. Jake Ansell and Mulhim Al-Doori. [899].
• Array morphology. Robert Bernecky. [900] (pdf).
• The role of APL and J in high-performance computation. Robert Bernecky. [901] (pdf).
• Approaching classical algorithms in APL2. Hanspeter Bieri and Felix Grimm. [902].
• Extending the APL character set. James A. Brown, Brent Hawks, and Ray Trimble. [903].
• SCARFS, an efficient polynomial zero-finder system. Tien Chi Chen. [904].
• The testing of an APL compiler. Wai-Mee Ching and Alex Katz. [905].
• APL helps the deaf to hear again. Pierre Deslauriers. [906].
• Structuring functions with operators. David S. Eastwood. [907].
• Confessions of two APL educators learning J. Murray Eisenberg and Howard A. Peelle. [908].
• A modern APL windows user interface with DOS downwards compatibility: the solution for two years onwards. Richard R. N. Eller. [909].
• A parallel topological feature map in APL. J. Frey, D. Scheppelmann, G.-P. Glombitza, and H. Meinzer. [910].
• Talking with an APL via DDE: teaching an old dog new tricks. Steven J. Halasz and Andrei V. Kondrashev. [911].
• APROL: a hybrid language. Dennis Holmes and John E. Howland. [912].
• Extending the two-partner shared variable protocol to n partners. Thomas Kolarik. [913].
• Building the APL atlas of natural shapes. Gérard A. Langlet. [914].
• Modern algebra self-taught through APL. Pavel Luksha. [915].
• Using defined operators and function arrays to solve non-linear equations in APL2. Stephen M. Mansour. [916].
• An introduction to log-linear analysis and implementing the Newton-Raphson algorithm in APL2. Duncan McArthur. [917].
• Distributed computing in the workstation environment. Johann Mitlöhner. [918].
• Transfinite nesting in array-theoretic figures, changes, rigs, and arms. Part I. Trenchard More. [919].
• APL programming without tears: it is time for a change. P. Naeve, B. Strohmeier, and P. Wolf. [920].
• Efficient maximum likelihood estimation of linear models with APL. Frank C. Ripley. [921].
• Roles of APL in satellite surveillance. Jack G. Rudd. [922].
• Extending APL2 to include program control structures. David A. Selby. [923].
• Solving two or three polynomials in two or three variables. R. G. Selfridge. [924].
• Adaptive learning networks in APL2. Alexander O. Skomorokhov. [925].
• Identification of parallelism in neural networks by simulation with language J.. Alexei N. Skurihin and Alvin J. Surkan. [926].
• Rolling dice: some notes on J and teaching probability. Keith Smillie. [927].
• Co-operative programming with Windows DDE. Adrian Smith. [928].
• JVOX. David G. Smith and Joey K. Tuttle. [929].
• Point-wise calculus. Walter G. Spunde. [930].
• From trees into boxes. David Steinbrook and Eugene McDonnell. [931].
• Bayesian methods in APL. Thomas W. Stroud, Alan M. Sykes, and Alan D. Mayer. [932].
• The workspace manager: a change control system for APL. Rexford H. Swain and Daniel F. Jonusz. [933].
• Understanding ANOVA the APL way. Norman Thomson. [934].
• Structured APL: a proposal for block structured control flow in APL. Robert G. Willhoft. [935].
• Recent work on the Toronto toolkit. Richard M. Levine. [936].

1994

• Geometric data of cross-sections of beams. Holger Besier. [937].
• LiSEB: a language for modeling living systems with APL2. P. Bottoni, M. Mariotto, and P. Mussio. [938].
• A new graphical user interface proposal for APL. Dick Bowman. [939].
• The origins of APL2. James A. Brown. [940].
• Programming in J/Windows. Chris Burke. [941].
• APL and economic education. Andrew Yu. Buzin. [942].
• Aberth’s method for the parallel iterative finding of polynomial zeros. Tien Chi Chen and Wai-Shing Luk. [943].
• Knowledge representation in expert systems in a linguistic form. Joris E. De Meyer. [944].
• A risk management prototype using object-oriented APL. Martin Gfeller. [945].
• New development of APL technology of modelling: APL*Plus + C++ compiler. Dmitri Gusev and Igor Pospelov. [946].
• TAGS: trains, agendas, and gerunds. Roger K. W. Hui and Kenneth E. Iverson. [947].
• An algebraic formula manipulation system for education and its implementation on different PCs. Makoto Kikkawa, Koichi Sugawara, and Yukio Washio. [948].
• Time series forecasting using neural networks. Thomas Kolarik and Gottfried Rudorfer. [949].
• A rating system for qualification analysis with application to personal evaluation. Alexi I. Kononov and Gennady A. Reimarov. [950].
• The APL theory of human vision. Gérard A. Langlet. [951].
• Statistical simulation and illustration using the APL2/AGSS computing environment. Peter A. W. Lewis. [952].
• Probabilistic studies of I Ching with use of APL. Pavel Luksha. [953].
• An implementation of prediction calculation using APL and Clipper. Inna N. Luneva, Sergei M. Obraztsov, and Alexander L. Shimkevich. [954].
• Necessity is the mother of invention or APL-Graphics application for maps of science. Boris A. Makeev and Alexander V. Zueva. [955].
• VDE: a virtual data engine for APL. J. Merrill. [956].
• Is APL2 a competitive language for international Olympiads in informatics. I. Mironov and V. Bargachev. [957].
• APL for statistical research of atmospheric flows during the dust storm. Aibarsha A. Mukanova. [958].
• Use of APL in Japan. Kyosuke Saigusa. [959].
• An object-oriented APL2. David A. Selby. [960].
• Simulation of mail warehouse: an APL2 solution for a large company problem. Alexander O. Skomorokhov. [961].
• A parallel correlation-based algorithm in J learns neural network connections. Alexei N. Skurikhin and Alvin J. Surkan. [962].
• The impact of APL on first year mathematics. Walter G. Spunde. [963].
• Analysing time-series in APL. Alan M. Sykes. [964].
• Applying matrix divide in APL and J. Norman Thomson. [965].
• Restriction riddance: more power to parentheses. F. H. D. van Batenburg. [966].

1995

• Is APL2 a good programming language?. Nicholas Beaumont. [967].
• The role of dynamic programming & control structures in performance. Robert Bernecky. [968] (pdf).
• Recycling APL code into client/server applications. Richard J. Busman, Walter G. Fil, and Andrei V. Kondrashev. [969].
• Infinity arithmetic, comparisons and J. Harvey Davies. [970].
• Deploying complex decision technologies with APL to solve the daily output planning problem: a tale from two of the last of the Jedi Knights. Kenneth Fordyce and Gerald Gary Sullivan. [971].
• Holland classifier systems. Andreas Geyer-Schulz. [972].
• Bounded rationality and adaptive agents in economic modeling. T. Grimm, J. Mitlöhner, and W. Schönfeldinger. [973].
• Translation of nested APL to C++: problems and approaches. Dmitri Gusev and Igor Pospelov. [974].
• Modeling the effects of acid leaching on concrete. Kevin Hartzfeld. [975].
• The philosophy of nothing and everything. Neville Holmes and Colin Hallam. [976].
• Rank and uniformity. Roger K. W. Hui. [977] (web).
• Representations of recursion. Roger K. W. Hui and Kenneth E. Iverson. [978].
• APL, dynamic programming, and the optimal control of electromagnetic brake retarders. Scott Kimbrough. [979].
• Regression analysis with fuzzy knowledge representation. Inna N. Louneva, Sergei M. Obraztsov, and Alexander L. Shimkevich. [980].
• The role of composition in computer programming. Donald B. McIntyre. [981].
• Computing multivariable Taylor series to arbitrary order. Richard D. Neidinger. [982].
• Untying the Gordian knot: agreement in J. Martin Neitzel. [983].
• AVCS: the APL version control system. Nikolai I. Puntikov, Maxim A. Volodin, and Alexei A. Kolesnikov. [984].
• Infix, cut and finite automata. Clifford A. Reiter. [985].
• Early bankruptcy detection using neural networks. Gottfried Rudorfer. [986].
• Fuzzy control of technological processes in APL2. Alexander O. Skomorokhov, K.-H. Reinhardt, G. Roche, and M. Tielemann. [987].
• Concrete multidimensional statistics in APL2. Bernhard Strohmeier. [988].
• Namespaces: APL/W vs. APL2. Rexford H. Swain. [989].
• Doing ANOVA calculations on the computer. Alan M. Sykes. [990].
• An APL implementation of the Club of Rome’s world model. Clare Townsend. [991].
• APL is important at USAA (abstract). Rhonda K. Aikens. [992].
• A new approach for developing applications using asynchronous AP144 and synchronous AP207 (abstract). Y. Akiyama and T. Itoh. [993].

1996

• User interfaces with object-oriented programming in APL2. Manuel Alfonseca. [994].
• Representation of fractal curves by means of L systems. Manuel Alfonseca and Alfonso Ortega. [995].
• Cross-tabulation algorithms. Martin Barghoorn. [996].
• Real-time APL prototype of a GPS system. Henry M. Beisner, Jack G. Rudd, and Robert H. Benner. [997].
• Song of the whale: parallel processing using APL2. Per Gjerløv and Izabela Meisel. [998].
• ANDYMMO: animation of the dynamics of mechanical and control models. Willi Hahn, Erwin Hasenjäger, and Jens Trautmann. [999].
• Using J as expository language in the teaching of computer science to liberal arts students. John E. Howland. [1,000].
• A proposal for calling conventions for APL defined functions. Vincent Lin. [1,001].
• Classifier systems and economic modeling. Johann Mitlöhner. [1,002].
• Economic forecasting by the deterministic-adaptive method. Sergei M. Obraztsov, Dmitri V. Chelegatski, Inna N. Louneva, and Alexander L. Shimkevich. [1,003].
• Genetic algorithms: APL2 implementation and a real life application. Alexander O. Skomorokhov. [1,004].

1997

• How to write an APL utility function. Stephen M. Mansour. [1,005].
• War on the workspace! supporting continuously changing commercial software using a relational database. Edward J. Shaw. [1,006].
• Data transfer between Java Applets and legacy APL systems. B. Amos, G. Disney, and D. Sorrey. [1,007].
• Mathematical roots of J. Roger K. W. Hui and Kenneth E. Iverson. [1,008].
• APL and nested arrays—a dream for statistical computation. Alan Sykes and Tom Stroud. [1,009].
• A constructive algorithm for neural networks that generalize. Alvin Surkan and Colin Campbell. [1,010].
• The computer construction of weaving designs. Keith Smillie. [1,011].
• Interactive design of structures: a program for everyone. Johann Riebenbauer and Joachim Hoffmann. [1,012].

1998

Website

• Using APL expressions in database operations. Paul S. Mansour and Stephen M. Mansour. [1,013].
• EGREGION: a branch coverage tool for APL. Robert Bernecky. [1,014] (pdf).
• Writing optimization software in APL, J, and MATLAB: a comparison. Richard L. W. Brown. [1,015].
• The comparison of C++ and Mathematica in the generation of pseudo random numbers for financial and actuarial applications. Marco Micocci, Angelo Manna, and Alvaro Tomassetti. [1,016].
• On defining application-specific high-level array operations by means of shape-invariant programming facilities. Sven-Bodo Scholz. [1,017].
• Reducing computational complexity with array predicates. Robert Bernecky. [1,018] (pdf).
• Turtle graphics: hidden features in APL2. Hendrik Rama. [1,019].
• All searches are divided into three parts: string searches using ternary trees. David E. Siegel. [1,020].
• An epistemology of APL. J. Philip Benkard. [1,021].
• Writing a compilers compiler in APL. Enrique Alfonseca. [1,022].
• Simplifying array processing languages. Neville Holmes. [1,023].
• Japanese language handling in APL environments. Kyosuke Saigusa. [1,024].
• Compiling a simulation language in APL. Manuel Alfonseca, Enrique Alfonseca, and Juan de Lara. [1,025].
• Crosstab, OLAP, and APL: N-dimensional data analysis with sparse cubes. Martin Barghoorn. [1,026].
• BABAPL: a software prototype of a programmable pocket APL calculator. Roger Busi. [1,027].
• Object oriented spatial positioning systems. István Kádár and Erik Papp. [1,028].
• AxE: a transportation network analysis package. Francesco Pedullá and Giorgio Salerno. [1,029].
• APL and demographic modelling. U. Piasentin, D. Lanari, and E. Migliorini. [1,030].
• Large-scale space object tracking using APL2. Jack G. Rudd, Richard A. Marsh, and Marcus L. Munger. [1,031].
• Pattern recognition in APL with application to reactor diagnostics. Alexander O. Skomorokhov and Michail T. Slepov. [1,032].
• Using APL to build science tutors for the high school level. Manuel Alfonseca. [1,033].
• Teaching classical calculation methods: APL challenge. Andrei Buzin. [1,034].
• First flight: automated tutorials for fledgling APLers. Steven J. Halasz. [1,035].
• A Web-interfaced array-based mathematics course. Walter Spunde and Peter de Voil. [1,036].
• APL design of graphic displays for motivation in distance education. Alvin J. Surkan. [1,037].
• Highly parallel computing in simulation on dynamic bond portfolio management. Vittorio Moriggia, Marida Bertocchi, and Jitka Dupaková. [1,038].
• The use of Markov discontinuous processes in the pricing of derivative securities: the application of APL. Marco Micocci. [1,039].
• Optimization with dynamic functions. Stephen M. Mansour. [1,040].
• Corporate analysis by APL. Arto Juvonen and Unto Niemi. [1,041].
• Neural network for partitionable variational inequalities. Giulia Rotondo. [1,042].

1999

• Generalization of Pick’s theorem for surface of polyhedra. Mihaly Agfalvi, Istvan Kadar, and Erik Papp. [1,043].
• When bears are blue and bulls are red. Linda Alvord and Tama Traberman. [1,044].
• Dynamic systems simulation using APL2. Robertas Alzbutas and Vytautas Janilionis. [1,045].
• Functions and data can dance as equal partners. J. Philip Benkard. [1,046].
• The Zark library of utility functions. Gary A. Bergquist. [1,047].
• Choices in server-side programming: a comparative programming exercise. Robert G. Brown and Willi Hahn. [1,048].
• Regions: an abstraction for expressing array computation. Bradford L. Chamberlain, E. Christopher Lewis, Calvin Lin, and Lawrence Snyder. [1,049].
• Accelerating APL programs with SAC. Clemens Grelck and Sven-Bodo Scholz. [1,050].
• Sparse arrays in J. Roger K. W. Hui. [1,051].
• INFO: interactive APL documentation. George Mebus. [1,052].
• A retro/prospective on APL Graphpak. Walt Niehoff. [1,053].
• Teaching J as a computer notation for secondary mathematics. Howard A. Peelle. [1,054].
• An object-oriented approach to educational software in building physics. Georg Reichard. [1,055].
• APL-generated teaching and testing items to enhance a student’s ability to discover functional relationships. Alvin J. Surkan. [1,056].
• GFSR pseudorandom number generation using APL. Charles Winton. [1,057].

2000s

2000

• Artificial life evolution in a simplified APL2 environment. Manuel Alfonseca. [1,058].
• Using APL2 to compute the dimension of a fractal represented as a grammar. Manuel Alfonseca and Alfonso Ortega. [1,059].
• Client-server based application in the dyalog APL environment. Alexander Balako. [1,060].
• High performance computing through parallel processing. Martin Barghoorn. [1,061].
• What’s wrong with APL2. James A. Brown. [1,062].
• Defining APL community: case studies, towards a revival of APL community. Robert G. Brown. [1,063].
• Object oriented APL: an introduction and overview. Robert G. Brown. [1,064].
• Interest made simple with arrays. Richard L. W. Brown. [1,065].
• APL tutorial in mathematical modelling. A. Buzin and I. Naftulin. [1,066].
• The design and implementation of an APL dialect, ELI. Wai-Mee Ching. [1,067].
• The killer app: how to make millions with ground-breaking software. Ian Clark. [1,068].
• Experiences with APL on a mainframe as a webserver. Bernd Geisselhardt. [1,069].
• Representation of ASN.1 in APL nested structures. Peter-Michael Hager. [1,070].
• An improved method for creating dynamic web forms using APL. Steven J. Halasz. [1,071].
• Dyalog-APL application with threads on the basis of ActiveX data objects. A. Karabanov, J. Korablev, and G. Roche. [1,072].
• Communication between PC and mainframe via TCP/IP using APL. Nils Kolster and Christian Nagel. [1,073].
• Avoiding the pitfalls of corporate intranets. Timo Laurmaa. [1,074].
• Noun phrase chunking with APL2. Suresh Manandhar and Enrique Alfonseca. [1,075].
• Houses, windows and DOHR’s: (descriptive object of high rank). Stephen M. Mansour. [1,076].
• SPARROW-a speech and knowledge based architecture for a workplace. Ruth Marzi. [1,077].
• GrAPL: a high-level statistical graphics language prototype. Alan D. Mayer and Alan M. Sykes. [1,078].
• High-level object oriented programming with array technology. Philippe Mougin. [1,079].
• APL Based medical image analysis. Tilman P. Otto. [1,080].
• An APL Compiler. Tilman P. Otto. [1,081].
• An integrated APL2 solution for population screening and control. Umberto Piasentin and Claudio Sandi. [1,082].
• Gerva: secure electronic legal communication with attributes. Dietmar Sengenleitner. [1,083].
• A knowledge discovery method: APL implementation and application. Alexander O. Skomorokhov. [1,084].
• Redistribution of totals through hierarchical data: an application of Benkard’s distributed round. Adrian Smith. [1,085].
• Spoken-word direction of computer program synthesis. Alvin J. Surkan. [1,086].
• An interface between Java and APL. Mike Symes. [1,087].
• Comparative file I/O methods in APL2. Nancy Wheeler. [1,088].
• Visual representation of document-oriented information on the web. Dmitriy Zlobin and Alexei Roudometkine. [1,089].
• Making of a conference: APL92, St.Petersburg, Russia. Erkki Juvonen. [1,090].
• An array based simulation approach for predicting the impact of different measles vaccination strategies in Lower Saxony. Johannes M. Dreesman. [1,091].
• Graph notation for arrays. Hans G. Ehrbar. [1,092].
• Handling context-sensitive syntactic issues in the design of a front-end for a MATLAB compiler. Pramod G. Joisha, Abhay Kanhere, Prithviraj Banerjee, U. Nagaraj Shenoy, and Alok Choudhary. [1,093].
• A symmetry-based formalism for array subtyping. A. Shafarenko. [1,094].

2001

• Correctly detecting intrinsic type errors in typeless languages such as MATLAB. Pramod G. Joisha and Prithviraj Banerjee. [1,095].
• J and sports betting. Pablo Landherr. [1,096].
• Replacing an explicit loop by the “each” operator. Samir Lipovaca and Joseph Burchfield. [1,097].
• An array-oriented (APL) wish list: ideas I think may be useful. Jim Lucas. [1,098].
• D2Cell data mining utility. John Manges. [1,099].
• A dynamic APL GUI equation solver (ADAGE). Stephen M. Mansour. [1,100].
• Good taste in color and soft palettes. Devon McCormick. [1,101].
• Embedding a Tcl web server into APL. Tilman P. Otto. [1,102].
• Graph coloring in J: an introduction. Howard A. Peelle. [1,103].
• Is there a way of combining array-processing and object-oriented programming?. George Reichard. [1,104].
• Array form representation of idiom recognition system for numerical programs. Sato Hiroyuki. [1,105].
• Classification trees in APL: implementation and application. Alexander Skomorokhov and Vladimir Kutinsky. [1,106].
• Suggestions for a method of analyzing binary images using Langlet’s parity logic. Stuart Smith. [1,107].
• A canon for the representation of multivariate arrays in the APL2 computing language. Richard Drexel Stockbridge. [1,108].

2002

• A WordNet interface to APL2. Enrique Alfonseca. [1,109].
• Complex systems in APL: fractals, evolving cellular automata and artificial life. Manuel Alfonseca, Alfonso Ortega, and Marina de la Cruz. [1,110].
• Bingo pricing: a game simulation and evaluation using APL. Antonio Annibali and Francesco Bellini. [1,111].
• Intelligent quota management system. Martin Barghoorn. [1,112].
• Evolution of an APL electronic document interchange system: over 19 years, 3000 installations, 100M documents, 5000 updates and 29,000 data labels. Georges Brigham. [1,113].
• Exhaustive representation of multiple instances using base-value discriminants. Georges Brigham. [1,114].
• SmartArrays for the APL programmer. James A. Brown and James G. Wheeler. [1,115].
• Using an APL approach with Java. Joseph Burchfield and Samir Lipovaca. [1,116].
• APL, a powerful research tool in magnetic resonance spectroscopy. Claude Chachaty. [1,117].
• Formal semantics of APL: a review of initial findings. Phil Chastney. [1,118].
• Vector Pascal an array language for multimedia code. Paul Cockshott. [1,119].
• A new calculus for multidimensional arrays. Stephen Eriksson-Bique. [1,120].
• Out-of-control structures. Jim Lucas. [1,121].
• Looking back on looking ahead. Jim Lucas. [1,122].
• An interface for user-defined functions in a database application. Stephen M. Mansour. [1,123].
• J and Dyalog APL sharing resources: can’t we all just get along?. Devon H. McCormick. [1,124].
• Delivering power with minimal restraint: APL and the web. David Mitchell. [1,125].
• Automatic composition of music by means of grammatical evolution. Alfonso Ortega de la Puente, Rafael Sánchez Alfonso, and Manuel Alfonseca Moreno. [1,126].
• SAPL: APL as client and server for SAP R2/R3 systems. Tilman P. Otto. [1,127].
• Porting the parallel array programming language ZPL to an embedded multicomputing system. Demetrio Rey, Joss Stubblefield, and James Canning. [1,128].
• 30 years of research in animal breeding: APL versus Matlab and Fortran. Marcos Rico and Manuel Baselga. [1,129].
• Dialog template description tool. Kyosuke Saigusa and Yoshinori Saigusa. [1,130].
• Jottings from the business intelligence jungle. David Selby. [1,131].
• Radial basis function networks in A+. Alexander Skomorokhov. [1,132].
• Experiences of A+ under windows. Adrian Smith. [1,133].
• Evolutionary discovery of algorithms as circuits for quantum computers. Alvin J. Surkan and Amiran Khuskivadze. [1,134].
• Dynamic graphic regression. Alan M. Sykes and Alan D. Mayer. [1,135].

2003

• Simulating ordered GRB color triples using J to create images with gradients in both hue and value. Linda Alvord and Tama Traberman. [1,136].
• Multidimensional corporate analysis: analytical and graphical approaches. Antonio Annibali and Francesco Bellini. [1,137].
• NAVPLANR (NP): flight navigation planning software. Dan Baronet. [1,138].
• An SPMD/SIMD parallel tokenizer for APL. Robert Bernecky. [1,139].
• Bitslice: representation without taxation. Robert Bernecky and Peter Wooster. [1,140].
• Useful formulas for multidimensional arrays. Stephen Bique. [1,141].
• An algorithm to compute all full-span sub arrays of a regular array. Ronald I. Frank. [1,142].
• A new “dual-view” diagram of array structure. Ronald I. Frank. [1,143].
• A generating function that counts the combinatorial full-span sub array structure of a regular array with some applications to APL. Ronald I. Frank. [1,144].
• Interesting inner-product scans. Curtis A. Jones. [1,145].
• Finite group tables in APL. Samir Lipovaca and Joseph Burchfield. [1,146].
• INSTRUCTOR: a new technique of guiding the user in simulation software. Georg Reichard. [1,147].
• Simulated APL session manager. Kyosuke Saigusa. [1,148].
• Bit arrays from row and column sums. R. G. Selfridge. [1,149].

2007

Website. No proceedings were published for the 2007 conference.

• An introduction to OO in APL. Dan Baronet.
• APL for Today (An Introduction To APL). Ray Polivka.
• What APL Can Teach the World (and vice versa). Guy Steele.
• No Experience Necessary: Hire for Aptitude - Train for Skills. Brooke Allen.
• Comparisons Between Array and Non-Array Approaches to Programming Problems. Devon McCormick.
• Generic Programming on the Nesting Structure of Arrays. Stephan Herhut Sven-Bodo Scholz Clemens Grelck.
• Arrays of objects, or objects containing arrays? Richard Nabavi.
• Melding Moore and Iverson: An Open Abstracted APL built in Forth for Intel processors. Bob Armstrong.
• Thinking in Arrays. Steve Rogers, Moderator, with:
  • Bob Armstrong (4th.cosy)
  • Robert Bernecky (APEX)
  • Mike Jenkins (Nial)
  • Morten Kromberg (Dyalog APL)
  • Jon McGrew (A+)
  • John Randall (J)
  • Steve Rogers (Numeric Python)
  • Sven-Bodo Scholz (SAC)
  • Loren Shure (Matlab)
• Using Objects in APLX Version 4. Richard Nabavi.
• A general introduction to SaC (for Single Assignment C). Stephan Herhut Sven-Bodo Scholz Clemens Grelck.
• Unicode Support for APL. Morten Kromberg.
• Programming with Arrays Lessons from Nial. Mike Jenkins.
• Advantages of Using an Interactive, Array-Based Language for Financial Research. Devon McCormick.
• SaC: customizing your own verbs and data types with little effort. Stephan Herhut Sven-Bodo Scholz Clemens Grelck.
• Design considerations for interfacing APL to other object-oriented languages. Richard Nabavi.
• Competing with J. John Randall.
• Arrays of objects. Morten Kromberg.
• APEX: The APL Parallel Executor. Robert Bernecky.
• Made for APL - the initial foray of an Aging Jedi Knight and light saber into the world of Bioinformatics and Cancer Research. Ken Fordyce.

2010s

2010

The APL 2010 conference was co-hosted with Dyalog Ltd. and so is also known as Dyalog '10.

Invited Paper

• IP1: Multi-/ Many-Cores: array programming at the heart of the hype! Dr. habil. Sven-Bodo Scholz (University of Hertfordshire, UK).
• IP2: APL and its Influence on Modern Computing. Dr. James A. Brown (CEO, SmartArrays, Inc.).

Keynote Speakers

• KN1: MultiCore & Hybrid Systems - New Computing Trends? Helmut Weber (IBM Deutschland RD GmbH).
• KN2: The Origins of the Computer. Prof. Dr.-Ing. Horst Zuse.

Reviewed Papers

• P01: APL# - An APL for Microsoft.Net, Mono, SilverLight and MoonLight. Morten Kromberg, Jonathan Manktelow, John Scholes (Dyalog Ltd.).
• P02: Unifying Traditional Functions and D-Fns in APL#. John Scholes, Jonathan Manktelow, Morten Kromberg (Dyalog Ltd.).
• P03: Processing Text Using Regular Expressions. Richard Smith (Dyalog Ltd.).
• P04: APLNext VisualAPL. Joe Blaze (APL2000).
• P05: APL+Win Interfaces. Joe Blaze (APL2000).
• P06: Hash arrays as Dyalog APL objects. Dr. Reiner Nussbaum.
• P07: Hashing for Tolerant Index-Of. Roger Hui.
• P08: Parallel Programming Theory and Examples Towards Sketching a Taxonomy for Problem Estimation. Devon McCormick.
• P09: APLNext Supervisor. Joe Blaze (APL2000).
• P10: Benefits and Limitations of Array-style Programs for Parallel Execution. Wai-Mee Ching, Da Zheng (Zhejiang Normal University, Jinhua, Zhejiang, China and Johns Hopkins University, Baltimore, Maryland, USA).
• P11: Parallel Computation Using Peach, Prank and Pouter. Morten Kromberg, Michael Hughes (Dyalog Ltd.).
• P12: Improving Violinists’ Intonation. Helmut Engelke.
• P13: Building reference systems in German health insurance. Markos Mitsos (DKV).
• P14: CPAM — Array Structured Product Data at Volvo Cars. Lars Wentzel (Fujitsu Sweden).
• P15: Automatic Determination of Weight for Railway Waggons. Martin Barghoorn (TU-Berlin).
• P16: New APL+Win System Features. Patrick Parks (APL2000).
• P17: Succinct - A new APL dialect. Dr. Herman Singer (Syndeon Soft).
• P18: Damage Resistant Component Files Using Journaling and Other Techniques. Richard Smith (Dyalog Ltd.).
• P19: Supporting APL keyboards on Linux. Geoff Streeter (Dyalog Ltd.).
• P20: Mask and Mesh Revisited. Robert Bernecky (Snake Island Research Inc.).

Reviewed Short Communications

• SC1: How to use an APL+Win application in a .NET environment. Volker Stamm, Bernd Stolle (a.k.e Software GmbH).
• SC2: APL Prototype Functions. Bob Smith (Sudley Place Software).
• SC3: The Enclose of a Simple Scalar. Dr. James A. Brown (CEO, SmartArrays, Inc.).

Tutorials

• TU1: Development Environment on the Workstation and Runtime Environment on the HOST? It works! Bernd Geisselhardt (Allianz Deutschland).
• TU2: APL+Win Performance. Patrick Parks (APL2000).
• TU3: User Commands in Dyalog APL. Dan Baronet (Dyalog Ltd.).
• TU4: APLWiki. Kai Jäger (APLTeam).
• TU5: APLNext WebServices. Joe Blaze (APL2000).

Workshops

• WS1: APL and Web Services. Brian Becker (Blue Dolphin Solutions).
• WS2: Introduction to D-Functions. John Scholes (Dyalog Ltd.).
• WS3: Windows Presentation Foundation. Michael Hughes and Morten Kromberg (Dyalog Ltd.).
• WS4: Using the Microsoft.Net Framework. John Daintree (Dyalog Ltd.).

Forum

• FO1: APL in 2020. Bob Smith (Chair) (Sudley Place Software).
• FO2: The Future of Parallel Computing with APL. Dr. James A. Brown (Chair) (CEO, SmartArrays, Inc.).

Selling Tutorials

• ST1: APL - why, when and where. Gitte Christensen (Dyalog Ltd.).
• ST2: Making Money with APL. Paul Grosvenor (optimasystems).

Vendor Sessions

• V01: WPF Presentation & APL Business Rules Components in a Windows Application System. Joe Blaze (APL2000).
• V02: APL+Win V10 Enhancements in Detail. Patrick Parks (APL2000).
• V03: APL+Win V10 Interpreter Performance Enhancement in Detail. Patrick Parks (APL2000).
• V04: APLNext Supervisor — A Simple Example. Joe Blaze (APL2000).
• V05: APL2000 Customer Forum. Joe Blaze (APL2000).
• V06: APLNext VisualAPL — Programming Examples. Joe Blaze (APL2000).
• V07: APLNext WebServices — A Practical Example. Joe Blaze (APL2000).
• V08: “MVC” and “Presentation Model” System Architecture for APL. Joe Blaze (APL2000).
• V09: STS.win - An APL2 OLAP Database. Klaus-Peter Friedrich (Rheinischer Sparkassen- und Giroverband (RSGV)).
• V10: APL2 at a Young Glance. Katrin Holzmüller and Vladimir Zakgeym (DPC GmbH).
• V11: Taking APL for a RIDE. John Daintree (Dyalog Ltd.).
• V12: Dyalog Technical Keynote. Morten Kromberg (Dyalog Ltd.).
• V13: An interpreter for Vanilla Siteswap. Jay Foad (Dyalog Ltd.).
• V14: Your Application as an SQL Data Source. Morten Kromberg (Dyalog Ltd.).
• V15: APL2XML. Kai Jäger (APLTeam).
• V16: Migrating SimCorp Dimension to Dyalog APL Unicode. Stig Nielsen (SimCorp A/S).
• V17: Winning the Dyalog Programming Contest 2010. Ryan Tarpine and Mstislav Elagin.
• V18: Using APL2 with Java and the WebSphere Application Server. David Liebtag (IBM APL Products and Services).
• V19: Recent APL2 Enhancements. David Liebtag (IBM APL Products and Services).