APL (programming language)

From Wikipedia, the free encyclopedia
  (Redirected from A programming language)
Jump to: navigation, search
APL
Paradigm Array, functional, structured, modular
Designed by Kenneth E. Iverson
Developer Kenneth E. Iverson
First appeared 1964; 54 years ago (1964)
Stable release
ISO/IEC 13751:2001 / 2001; 17 years ago (2001)
Typing discipline Dynamic
Platform
OS Windows, macOS, OS/2, AIX, Linux, Solaris, CP/M, VAX/VMS
License Proprietary, open source
Major implementations
  • Dyalog APL
  • IBM APL2
  • APL2000
  • Sharp APL
  • APLX
  • NARS2000[1]
  • GNU APL[2]
  • VAX APL[3]
Dialects
Influenced by
Mathematical notation
Influenced

APL (named after the book A Programming Language)[10] is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols[11] to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming,[12] and computer math packages.[6] It has also inspired several other programming languages.[4][5][7]

History[edit]

Mathematical notation[edit]

A mathematical notation for manipulating arrays was developed by Kenneth E. Iverson, starting in 1957 at Harvard University. In 1960, he began work for IBM where he developed this notation with Adin Falkoff and published it in his book A Programming Language in 1962.[10] The preface states its premise:

Applied mathematics is largely concerned with the design and analysis of explicit procedures for calculating the exact or approximate values of various functions. Such explicit procedures are called algorithms or programs. Because an effective notation for the description of programs exhibits considerable syntactic structure, it is called a programming language.

This notation was used inside IBM for short research reports on computer systems, such as the Burroughs B5000 and its stack mechanism when stack machines versus register machines were being evaluated by IBM for upcoming computers.

Iverson also used his notation in a draft of the chapter A Programming Language, written for a book he was writing with Fred Brooks, Automatic Data Processing, which would be published in 1963.[13][14]

In 1979, Iverson received the Turing Award for his work on APL.[15]

Development into a computer programming language[edit]

As early as 1962, the first attempt to use the notation to describe a complete computer system happened after Falkoff discussed with Dr. William C. Carter his work to standardize the instruction set for the machines that later became the IBM System/360 family.

In 1963, Herbert Hellerman, working at the IBM Systems Research Institute, implemented a part of the notation on an IBM 1620 computer, and it was used by students in a special high school course on calculating transcendental functions by series summation. Students tested their code in Hellerman's lab. This implementation of a part of the notation was called Personalized Array Translator (PAT).[16]

In 1963, Falkoff, Iverson, and Edward H. Sussenguth Jr., all working at IBM, used the notation for a formal description of the IBM System/360 series machine architecture and functionality, which resulted in a paper published in IBM Systems Journal in 1964. After this was published, the team turned their attention to an implementation of the notation on a computer system. One of the motivations for this focus of implementation was the interest of John L. Lawrence who had new duties with Science Research Associates, an educational company bought by IBM in 1964. Lawrence asked Iverson and his group to help use the language as a tool to develop and use computers in education.[17]

After Lawrence M. Breed and Philip S. Abrams of Stanford University joined the team at IBM Research, they continued their prior work on an implementation programmed in FORTRAN IV for a part of the notation which had been done for the IBM 7090 computer running on the IBSYS operating system. This work was finished in late 1965 and later named IVSYS (for Iverson system). The basis of this implementation was described in detail by Abrams in a Stanford University Technical Report, "An Interpreter for Iverson Notation" in 1966.[18] this was formally supervised by Niklaus Wirth. Like Hellerman's PAT system earlier, this implementation did not include the APL character set but used special English reserved words for functions and operators. The system was later adapted for a time-sharing system and, by November 1966, it had been reprogrammed for the IBM System/360 Model 50 computer running in a time sharing mode and was used internally at IBM.[19]

Hardware[edit]

IBM typeballs (one OCR) with clip, €2 coin for scale
A programmer's view of the IBM 2741 keyboard layout with the APL typing element print head inserted

A key development in the ability to use APL effectively, before the wide use of cathode ray tube (CRT) terminals, was the development of a special IBM Selectric typewriter interchangeable typing element with all the special APL characters on it. This was used on paper printing terminal workstations using the Selectric typewriter and typing element mechanism, such as the IBM 1050 and IBM 2741 terminal. Keycaps could be placed over the normal keys to show which APL characters would be entered and typed when that key was struck. For the first time, a programmer could type in and see proper APL characters as used in Iverson's notation and not be forced to use awkward English keyword representations of them. Falkoff and Iverson had the special APL Selectric typing element, 987 and 988, designed in late 1964, although no APL computer system was available to use them.[20] Iverson cited Falkoff as the inspiration for the idea of using an IBM Selectric typing element for the APL character set.[21]

Some APL symbols, even with the APL characters on the Selectric typing element, still had to be typed in by over-striking two extant element characters. An example is the grade up character, which had to be made from a delta (shift-H) and a Sheffer stroke (shift-M). This was necessary because the APL character set was larger than the 88 characters allowed on the typing element.

Commercial availability[edit]

The first APL interactive login and creation of an APL workspace was in 1966 by Larry Breed using an IBM 1050 terminal at the IBM Mohansic Labs near Thomas J. Watson Research Center, the home of APL, in Yorktown Heights, New York.[20]

IBM was chiefly responsible for introducing APL to the marketplace. APL was first available in 1967 for the IBM 1130 as APL\1130.[22][23] It would run in as little as 8k 16-bit words of memory, and used a dedicated 1 megabyte hard disk.

APL gained its foothold on mainframe timesharing systems from the late 1960s through the early 1980s, in part because it would run on lower-specification systems that had no dynamic address translation hardware.[24] Additional improvements in performance for selected IBM System/370 mainframe systems included the APL Assist Microcode in which some support for APL execution was included in the processor's firmware, versus APL being a software product exclusively. Somewhat later, as suitably performing hardware was finally growing available in the mid- to late-1980s, many users migrated their applications to the personal computer environment.

Early IBM APL interpreters for IBM 360 and IBM 370 hardware implemented their own multi-user management instead of relying on the host services, thus they were their own timesharing systems. First introduced in 1966, the APL\360[25][26][27] system was a multi-user interpreter. The ability to programmatically communicate with the operating system for information and setting interpreter system variables was done through special privileged "I-beam" functions, using both monadic and dyadic operations.[28]

In 1973, IBM released APL.SV, which was a continuation of the same product, but which offered shared variables as a means to access facilities outside of the APL system, such as operating system files. In the mid-1970s, the IBM mainframe interpreter was even adapted for use on the IBM 5100 desktop computer, which had a small CRT and an APL keyboard, when most other small computers of the time only offered BASIC. In the 1980s, the VSAPL program product enjoyed wide use with Conversational Monitor System (CMS), Time Sharing Option (TSO), VSPC, MUSIC/SP, and CICS users.

In 1973-1974, Dr. Patrick E. Hagerty directed the implementation of the University of Maryland APL interpreter for the 1100 line of the Sperry UNIVAC 1100/2200 series mainframe computers.[29] At the time, Sperry had nothing. In 1974, student Alan Stebbens was assigned the task of implementing an internal function.[30]

In the 1960s and 1970s, several timesharing firms arose that sold APL services using modified versions of the IBM APL\360[27] interpreter. In North America, the better-known ones were I. P. Sharp Associates, Scientific Time Sharing Corporation (STSC), Time Sharing Resources (TSR), and The Computer Company (TCC). CompuServe also entered the market in 1978 with an APL Interpreter based on a modified version of Digital Equipment Corp and Carnegie Mellon's, which ran on DEC's KI and KL 36-bit machines. CompuServe's APL was available both to its commercial market and the consumer information service. With the advent first of less expensive mainframes such as the IBM 4300, and later the personal computer, by the mid-1980s, the timesharing industry was all but gone.

Sharp APL was available from I. P. Sharp Associates, first as a timesharing service in the 1960s, and later as a program product starting around 1979. Sharp APL was an advanced APL implementation with many language extensions, such as packages (the ability to put one or more objects into a single variable), file system, nested arrays, and shared variables.

APL interpreters were available from other mainframe and mini-computer manufacturers also, notably Burroughs, Control Data Corporation (CDC), Data General, Digital Equipment Corporation (DEC), Harris, Hewlett-Packard (HP), Siemens AG, Xerox, and others.

Garth Foster of Syracuse University sponsored regular meetings of the APL implementers' community at Syracuse's Minnowbrook Conference Center in Blue Mountain Lake, New York. In later years, Eugene McDonnell organized similar meetings at the Asilomar Conference Grounds near Monterey, California, and at Pajaro Dunes near Watsonville, California. The SIGAPL special interest group of the Association for Computing Machinery continues to support the APL community.[31]

Microcomputers[edit]

APL was available on the first general purpose personal computer, the Intel 8008-based MCM/70, in 1973 and many further implementations followed.[citation needed] The early microcomputers were limited in capability and were slow but very convenient for use in education and often more cost effective and accessible than the time sharing services then available.[citation needed]

APL2[edit]

Starting in the early 1980s, IBM APL development, under the leadership of Dr Jim Brown, implemented a new version of the APL language that contained as its primary enhancement the concept of nested arrays, where an array can contain other arrays, and new language features which facilitated integrating nested arrays into program workflow. Ken Iverson, no longer in control of the development of the APL language, left IBM and joined I. P. Sharp Associates, where one of his major contributions was directing the evolution of Sharp APL to be more in accord with his vision.[32][33][34]

As other vendors were busy developing APL interpreters for new hardware, notably Unix-based microcomputers, APL2 was almost always the standard chosen for new APL interpreter developments. Even today, most APL vendors or their users cite APL2 compatibility, as a selling point for those products.[35][36]

APL2 for IBM mainframe computers is still available. IBM cites its use for problem solving, system design, prototyping, engineering and scientific computations, expert systems,[37] for teaching mathematics and other subjects, visualization and database access[38] and was first available for CMS and TSO in 1984.[39] The APL2 Workstation edition (Windows, OS/2, AIX, Linux, and Solaris) followed much later in the early 1990s.[citation needed]

Modern implementations[edit]

Various implementations of APL by APLX, Dyalog, et al., include extensions for object-oriented programming, support for .NET Framework, XML-array conversion primitives, graphing, operating system interfaces, and lambda calculus expressions.

Derivative languages[edit]

APL has formed the basis of, or influenced, the following languages:

  • LYaPAS, a Russian extension to APL.
  • A and A+, an alternative APL, the latter with graphical extensions.
  • J, which was also designed by Iverson, and which uses ASCII with digraphs instead of special symbols.
  • K, a proprietary variant of APL developed by Arthur Whitney.
  • MATLAB, a numerical computation tool.

Language characteristics[edit]

Character set[edit]

APL has been both criticized and praised for its choice of a unique, non-standard character set. Some who learn it become ardent adherents, suggesting that there is some weight behind Iverson's idea that the notation used does make a difference. In the 1960s and 1970s, few terminal devices and even display monitors could reproduce the APL character set. The most popular ones employed the IBM Selectric print mechanism used with a special APL type element. One of the early APL line terminals (line-mode operation only, not full screen) was the Texas Instruments TI Model 745 (circa 1977) with the full APL character set[40] which featured half and full duplex telecommunications modes, for interacting with an APL time-sharing service or remote mainframe to run a remote computer job, called an RJE.

Over time, with the universal use of high-quality graphic displays, printing devices and Unicode support, the APL character font problem has largely been eliminated. However, entering APL characters requires the use of input method editors, keyboard mappings, virtual/on-screen APL symbol sets,[41][42] or easy-reference printed keyboard cards which can frustrate beginners accustomed to other programming languages.[43][44][45] With beginners who have no prior experience with other programming languages, a study involving high school students found that typing and using APL characters did not hinder the students in any measurable way.[46]

In defense of APL use, APL requires less coding to type in, and keyboard mappings become memorized over time. Also, special APL keyboards are manufactured and in use today, as are freely available downloadable fonts for operating systems such as Microsoft Windows.[47] The reported productivity gains assume that one will spend enough time working in APL to make it worthwhile to memorize the symbols, their semantics, and keyboard mappings.[citation needed]

Design[edit]

Unlike traditionally structured programming languages, APL code is typically structured as chains of monadic or dyadic functions, and operators[48] acting on arrays.[49] APL has many nonstandard primitives (functions and operators) that are indicated by a single symbol or a combination of a few symbols. All primitives are defined to have the same precedence, and always associate to the right. Thus, APL is read or best understood from right-to-left.

Early APL implementations (circa 1970 or so) had no programming loop-flow control structures, such as do or while loops, and if-then-else constructs. Instead, they used array operations, and use of structured programming constructs was often not necessary, since an operation could be performed on a full array in one statement. For example, the iota function (ι) can replace for-loop iteration: ιN when applied to a scalar positive integer yields a one-dimensional array (vector), 1 2 3 ... N. More recent implementations of APL generally include comprehensive control structures, so that data structure and program control flow can be clearly and cleanly separated.

The APL environment is called a workspace. In a workspace the user can define programs and data, i.e., the data values exist also outside the programs, and the user can also manipulate the data without having to define a program.[50] In the examples below, the APL interpreter first types six spaces before awaiting the user's input. Its own output starts in column one.

      n  4 5 6 7
Assigns vector of values, {4 5 6 7}, to variable n, an array create operation. An equivalent yet more concise APL expression would be n 3 + 4. Multiple values are stored in array n, the operation performed without formal loops or control flow language.
      n 
4 5 6 7
Display the contents of n, currently an array or vector.
      n+4
8 9 10 11
4 is now added to all elements of vector n, creating a 4-element vector {8 9 10 11}.
As above, APL's interpreter displays the result because the expression's value was not assigned to a variable (with a ).
      +/n
22
APL displays the sum of components of the vector n, i.e., 22 (= 4 + 5 + 6 + 7) using a very compact notation: read +/ as "plus, over..." and a slight change would be "multiply, over..."
      m  +/(3+⍳4)
      m
22
These operations can be combined into one statement, remembering that APL evaluates expressions right to left: first 4 creates an array, [1,2,3,4], then 3 is added to each component, which are summed together and the result stored in variable m, finally displayed.

In normal mathematical notation, it is equivalent to: . Recall that mathematical expressions are not read or evaluated from right-to-left.

The user can save the workspace with all values, programs, and execution status.

APL is well known for its use of a set of non-ASCII symbols, which are an extension of traditional arithmetic and algebraic notation. Having single character names for single instruction, multiple data (SIMD) vector functions is one way that APL enables compact formulation of algorithms for data transformation such as computing Conway's Game of Life in one line of code.[51] In nearly all versions of APL, it is theoretically possible to express any computable function in one expression, that is, in one line of code.

Because of the unusual character set, many programmers use special keyboards with APL keytops to write APL code.[52] Although there are various ways to write APL code using only ASCII characters,[53] in practice it is almost never done. (This may be thought to support Iverson's thesis about notation as a tool of thought.[54]) Most if not all modern implementations use standard keyboard layouts, with special mappings or input method editors to access non-ASCII characters. Historically, the APL font has been distinctive, with uppercase italic alphabetic characters and upright numerals and symbols. Most vendors continue to display the APL character set in a custom font.

Advocates of APL[who?] claim that the examples of so-called write-only code (badly written and almost incomprehensible code) are almost invariably examples of poor programming practice or novice mistakes, which can occur in any language. Advocates also claim that they are far more productive with APL than with more conventional computer languages, and that working software can be implemented in far less time and with far fewer programmers than using other technology.

They also may claim that because it is compact and terse, APL lends itself well to larger-scale software development and complexity, because the number of lines of code can be reduced greatly. Many APL advocates and practitioners also view standard programming languages such as COBOL and Java as being comparatively tedious. APL is often found where time-to-market is important, such as with trading systems.[55][56][57][58]

Terminology[edit]

APL makes a clear distinction between functions and operators.[48][59] Functions take arrays (variables or constants or expressions) as arguments, and return arrays as results. Operators (similar to higher-order functions) take functions or arrays as arguments, and derive related functions. For example, the sum function is derived by applying the reduction operator to the addition function. Applying the same reduction operator to the maximum function (which returns the larger of two numbers) derives a function which returns the largest of a group (vector) of numbers. In the J language, Iverson substituted the terms verb for function and adverb or conjunction for operator.

APL also identifies those features built into the language, and represented by a symbol, or a fixed combination of symbols, as primitives. Most primitives are either functions or operators. Coding APL is largely a process of writing non-primitive functions and (in some versions of APL) operators. However a few primitives are considered to be neither functions nor operators, most noticeably assignment.

Some words used in APL literature have meanings that differ from those in both mathematics and the generality of computer science.

Term Description
function operation or mapping that takes zero, one (right) or two (left & right) arguments which may be scalars, arrays, or more complicated structures, and may return a similarly complex result. A function may be:
  • Primitive: built-in and represented by a single glyph;[60]
  • Defined: as a named and ordered collection of program statements;[60]
  • Derived: as a combination of an operator with its arguments.[60]
array data valued object of zero or more orthogonal dimensions in row-major order in which each item is a primitive scalar datum or another array.[61]
niladic not taking or requiring any arguments,[62]
monadic requiring only one argument; on the right for a function, on the left for an operator, unary[62]
dyadic requiring both a left and a right argument, binary[62]
ambivalent or monadic capable of use in a monadic or dyadic context, permitting its left argument to be elided[60]
operator operation or mapping that takes one (left) or two (left & right) function or array valued arguments (operands) and derives a function. An operator may be:
  • Primitive: built-in and represented by a single glyph;[60]
  • Defined: as a named and ordered collection of program statements.[60]

Syntax[edit]

APL has explicit representations of functions, operators, and syntax, thus providing a basis for the clear and explicit statement of extended facilities in the language, and tools to experiment on them.[63]

Examples[edit]

Hello, World[edit]

This displays "Hello, world":

'Hello, world'

'Hello World,' sample user session on YouTube[64]

A design theme in APL is to define default actions in some cases that would produce syntax errors in most other programming languages.

The 'Hello, world' string constant above displays, because display is the default action on any expression for which no action is specified explicitly (e.g. assignment, function parameter).

Exponentiation[edit]

Another example of this theme is that exponentiation in APL is written as "2⋆3", which indicates raising 2 to the power 3 (this would be written as "2^3" in some other languages and "2**3" in FORTRAN and Python). However, if no base is specified (as with the statement "⋆3" in APL, or "^3" in other languages), most other programming languages one would have a syntax error. APL however assumes the missing base to be the natural logarithm constant e (2.71828....), and so interpreting "⋆3" as "2.71828⋆3".

Pick 6 lottery numbers[edit]

This following immediate-mode expression generates a typical set of Pick 6 lottery numbers: six pseudo-random integers ranging from 1 to 40, guaranteed non-repeating, and displays them sorted in ascending order:

x[x6?40]

The above does a lot, concisely; although it seems complex to a new APLer. It combines the following APL functions (also called primitives[65] and glyphs[66]):

  • The first to be executed (APL executes from rightmost to leftmost) is dyadic function ? (named deal when dyadic) that returns a vector consisting of a select number (left argument: 6 in this case) of random integers ranging from 1 to a specified maximum (right argument: 40 in this case), which, if said maximum ≥ vector length, is guaranteed to be non-repeating; thus, generate/create 6 random integers ranging from 1-40.[67]
  • This vector is then assigned () to the variable x, because it is needed later.
  • This vector is then sorted in ascending order by a monadic function, which has as its right argument everything to the right of it up to the next unbalanced close-bracket or close-parenthesis. The result of is the indices that will put its argument into ascending order.
  • Then the output of is used to index the variable x, which we saved earlier for this purpose, thereby selecting its items in ascending sequence.

Since there is no function to the left of the left-most x to tell APL what to do with the result, it simply outputs it to the display (on a single line, separated by spaces) without needing any explicit instruction to do that.

? also has a monadic equivalent called roll, which simply returns one random integer between 1 and its sole operand [to the right of it], inclusive. Thus, a role-playing game program might use the expression ?20 to roll a twenty-sided die.

Prime numbers[edit]

The following expression finds all prime numbers from 1 to R. In both time and space, the calculation complexity is (in Big O notation).

(~RR∘.×R)/R1ιR

Executed from right to left, this means:

  • Iota ι creates a vector containing integers from 1 to R (if R= 6 at the start of the program, ιR is 1 2 3 4 5 6)
  • Drop first element of this vector ( function), i.e., 1. So 1↓ιR is 2 3 4 5 6
  • Set R to the new vector (, assignment primitive), i.e., 2 3 4 5 6
  • The / reduction operator is dyadic (binary) and the interpreter first evaluates its left argument (fully in parentheses):
  • Generate outer product of R multiplied by R, i.e., a matrix that is the multiplication table of R by R (°.× operator), i.e.,
4 6 8 10 12
6 9 12 15 18
8 12 16 20 24
10 15 20 25 30
12 18 24 30 36
  • Build a vector the same length as R with 1 in each place where the corresponding number in R is in the outer product matrix (, set inclusion or element of or Epsilon operator), i.e., 0 0 1 0 1
  • Logically negate (not) values in the vector (change zeros to ones and ones to zeros) (, logical not or Tilde operator), i.e., 1 1 0 1 0
  • Select the items in R for which the corresponding element is 1 (/ reduction operator), i.e., 2 3 5

(Note, this assumes the APL origin is 1, i.e., indices start with 1. APL can be set to use 0 as the origin, so that ι6 is 0 1 2 3 4 5, which is convenient for some calculations.)

Sorting[edit]

The following expression sorts a word list stored in matrix X according to word length:

X[X+.' ';]

Game of Life[edit]

The following function "life", written in Dyalog APL, takes a boolean matrix and calculates the new generation according to Conway's Game of Life. It demonstrates the power of APL to implement a complex algorithm in very little code, but it is also very hard to follow unless one has advanced knowledge of APL.

life{1 .3 4=+/,¯1 0 1∘.¯1 0 1∘.⌽⊂}

HTML tags removal[edit]

In the following example, also Dyalog, the first line assigns some HTML code to a variable txt and then uses an APL expression to remove all the HTML tags (explanation):

txt'<html><body><p>This is <em>emphasized</em> text.</p></body></html>'
{/⍨~{∨≠\}'<>'}txt

This returns the text This is emphasized text.

Program execution[edit]

APL programs are normally interpreted. Because APL's core objects are arrays,[68] it lends itself well to parallelism,[69] parallel computing,[70][71] massively parallel applications,[72][73] and very-large-scale integration or VLSI.[74][75]

Compilers[edit]

Most APL compilers translate source APL to a lower level intermediate language such as C, leaving the machine-specific details to the lower level compiler. Compiling APL programs was a topic discussed often at conferences. Although some of the newer enhancements to the APL language such as nested arrays have rendered the language increasingly difficult to compile, the idea of APL compiling is still under development today.

In the past[when?], APL compiling was regarded as a means to achieve execution speed comparable to other mainstream languages, especially on mainframe computers. Several APL compilers achieved some successes, though comparatively little of the development effort spent on APL over the years went to perfecting compiling into machine code.

As is the case when moving APL programs from one vendor's APL interpreter to another, APL programs invariably will require changes to their content. Depending on the compiler, variable declarations might be needed, some language features would need to be removed or avoided, or the APL programs would need to be cleaned up in some way. Some features of the language, such as the execute function (an expression evaluator) and the various reflection and introspection functions from APL, such as the ability to return a function's text or to materialize a new function from text, are simply not practical to implement in machine code compiling.

Matrix optimizations[edit]

APL was unique in the speed with which it could perform complicated matrix operations. For example, a very large matrix multiplication would take only a few seconds on a machine that was much less powerful than those today and, "because it operates on arrays and performs operations like matrix inversion internally, well written APL can be surprisingly fast."[76][77]

Use[edit]

APL is used for many purposes including financial and insurance applications,[78] artificial intelligence,[79][80] neural networks[81] and robotics.[82] It has been argued that APL is a calculation tool and not a programming language;[83] its symbolic nature and array capabilities have made it popular with domain experts and data scientists[84] who do not have or require the skills of a computer programmer.

APL is well suited to image manipulation and computer animation, where graphic transformations can be encoded as matrix multiplications. One of the first commercial computer graphics houses, Digital Effects, produced an APL graphics product named Visions, which was used to create television commercials and animation for the 1982 film Tron.[85] Latterly, the Stormwind boating simulator uses APL to implement its physics engine.[86]

Today, APL remains in use in a wide range of commercial and scientific applications, for example investment management,[78] asset management,[87] health care,[88] and DNA profiling,[89][90] and by hobbyists.[91]

Notable implementations[edit]

Interpreters[edit]

The first microcomputer implementation of APL was on the Intel 8008-based MCM/70, the first general purpose personal computer, in 1973. Size of arrays along any dimension could be no larger than 255 and the machine was quite slow, but very convenient for use in education. Interestingly, a significant part of sales were to small businesses, who found it more cost effective and accessible than the time sharing services then available, and for whom the array size limits were no barrier.

IBM's own IBM 5100 microcomputer (1975) offered APL as one of two built-in ROM-based interpreted languages for the computer, complete with a keyboard and display that supported all the special symbols used in the language. While the 5100 was very slow and operated its screen only like a typewriter, its successor the 5110 had more acceptable performance and a read-write addressable text screen. Graphics could be printed on an external matrix printer.

In 1976 DNA Systems introduced an APL interpreter for their TSO Operating System, which ran timesharing on the IBM 1130, Digital Scientific Meta-4, General Automation GA 18/30 and Computer Hardware CHI 21/30.

The VideoBrain Family Computer, released in 1977, only had one programming language available for it, and that was a dialect of APL called APL/S.[92]

A Small APL for the Intel 8080 called EMPL was released in 1977, and Softronics APL, with most of the functions of full APL, for 8080-based CP/M systems was released in 1979.

In 1977, the Canadian firm Telecompute Integrated Systems, Inc. released a business-oriented APL interpreter named TIS APL, for Z80-based systems. It featured the full set of file functions for APL, plus a full screen input and switching of right and left arguments for most dyadic operators by introducing the ~. prefix to all single character dyadic functions such as - or /.

Vanguard APL was available for Zilog Z80 CP/M-based processors in the late 1970s. The Computer Company (TCC) released APL.68000 in the early 1980s for Motorola 68000-based processors, this system being the basis for MicroAPL Limited's APLX product. I. P. Sharp Associates released a version of their APL interpreter for the IBM PC and PC-XT/370.[93] For the IBM PC, an emulator was written that facilitated reusing much of the IBM 370 mainframe code. Arguably, the best known APL interpreter for the IBM Personal Computer was Scientific Time Sharing Corporation's (STSC) APL*Plus/PC.[citation needed]

The Commodore SuperPET, introduced in 1981, included an APL interpreter developed by the University of Waterloo.

In the early 1980s, the Analogic Corporation developed The APL Machine, which was an array processing computer designed to be programmed only in APL. There were three processing units, the user's workstation, an IBM PC, where programs were entered and edited, a Motorola 68000 processor that ran the APL interpreter, and the Analogic array processor that executed the primitives.[94] At the time of its introduction, The APL Machine was likely the fastest APL system available. Although a technological success, The APL Machine was a marketing failure. The initial version supported a single process at a time. At the time the project was discontinued, the design had been completed to allow multiple users. As an aside, an unusual aspect of The APL Machine was that the library of workspaces was organized such that a single function or variable that was shared by many workspaces existed only once in the library. Several of the members of The APL Machine project had formerly spent several years with Burroughs implementing APL\700.

At one time, Bill Gates claimed in his Open Letter to Hobbyists, that Microsoft Corporation planned to release a version of APL, but that never occurred.

An early 1978 publication of Rodnay Zaks from Sybex was A microprogrammed APL implementation ISBN 0-89588-005-9, which is the complete source listing for the microcode for a Digital Scientific Corporation Meta 4 microprogrammable processor implementing APL. This topic was also the subject of his PhD thesis.[95][96]

In 1979, William Yerazunis wrote a partial version of APL in Prime Computer FORTRAN, extended it with graphics primitives, and released it. This was also the subject of his Masters thesis.[97]

APLNext (formerly APL2000) offers an advanced APL interpreter that operates on Linux, Unix, and Windows. It supports Windows automation, calls to operating system and user defined dynamic-link librarys (DLL), has an advanced APL File System, and represents the current level of APL language development. APL2000's product is an advanced continuation of Scientific Time Sharing Corporation's (STSC) successful APL*Plus/PC and APL*Plus/386 product line.

Dyalog APL is an advanced APL interpreter that operates on AIX, Linux (including on the Raspberry Pi), macOS and Microsoft Windows.[98] Dyalog has extensions to the APL language, which include new object-oriented programming features, many language enhancements, plus a consistent namespace model used for both its Microsoft Automation interface, and native namespaces. For the Windows platform, Dyalog APL offers tight integration with .NET, plus limited integration with the Microsoft Visual Studio development platform.

IBM offers a version of IBM APL2 for IBM AIX, Linux, Sun Solaris and Windows systems. This product is a continuation of APL2 offered for IBM mainframes. IBM APL2 was arguably the most influential APL system, which provided a solid implementation standard for the next set of extensions to the language, focusing on nested arrays.

NARS2000 is an open-source APL interpreter written by Bob Smith, a well-known APL developer and implementor from STSC in the 1970s and 1980s. NARS2000 contains advanced features and new datatypes, runs natively on Windows (32- and 64-bit versions), and runs on Linux and Apple macOS with Wine.

MicroAPL Limited offers APLX, a full-featured 64-bit interpreter for Linux, Microsoft Windows, and macOS systems. The core language is closely modelled on IBM's APL2 with various enhancements. APLX includes close integration with .NET Framework, Java, Ruby, and R. Effective July 11, 2016,[99] MicroAPL withdrew APLX from commercial sale. Dyalog began hosting the APLX website including the download area and documentation.

Soliton Incorporated offers the Sharp APL for UniX (SAX) interpreter, for Unix and Linux systems. This is a further development of I. P. Sharp Associates' Sharp APL product. Unlike most other APL interpreters, Kenneth E. Iverson had some influence in the way nested arrays were implemented in Sharp APL and SAX. Nearly all other APL implementations followed the course set by IBM with APL2, thus some important details in Sharp APL differ from other implementations.

OpenAPL is an open-source software implementation of APL, published by Branko Bratkovic. It is based on code by Ken Thompson of Bell Laboratories, together with contributions by others. It is licensed under the GNU General Public License, and runs on Unix systems including Linux on x86, SPARC, and other central processing units (CPU).

GNU APL is a free implementation of ISO Standard 13751 and thus similar to APL2. It runs on GNU/Linux, and on Windows using Cygwin. It uses Unicode internally. It was written by Jürgen Sauermann.

Compilers[edit]

A commercial compiler was brought to market by STSC in the mid-1980s as an add-on to IBM's VSAPL Program Product.[100][101] Unlike more modern APL compilers, this product produced machine code that would execute only in the interpreter environment, it was not possible to eliminate the interpreter component. The compiler could compile many scalar and vector operations to machine code, but it would rely on the APL interpreter's services to perform some more advanced functions, rather than attempt to compile them. However, dramatic speedups did occur, especially for heavily iterative APL code.

Around the same time, the book An APL Compiler by Timothy Budd appeared in print.[102] This book detailed the construction of an APL translator (aplc),[103] written in C, which performed some optimizations such as loop fusion specific to the needs of an array language. The source language was APL-like in that a few rules of the APL language were changed or relaxed to permit more efficient compiling. The translator would emit C code which could then be compiled and run outside of the APL workspace. Another compiler, also named aplc, was later created by Samuel W. Sirlin, based on Budd's work.[104]

The Burroughs/Unisys APLB interpreter (1982) was the first to use dynamic incremental compiling to produce code for an APL-specific virtual machine. It recompiled on-the-fly as identifiers changed their functional meanings. In addition to removing parsing and some error checking from the main execution path, such compiling also streamlines the repeated entry and exit of user-defined functional operands. This avoids the stack setup and take-down for function calls made by APL's built-in operators such as Reduce and Each.

APEX, a research APL compiler, is available under the GNU Public License, per Snake Island Research Inc.[106] APEX compiles flat APL (a subset of ISO N8485) into SAC, a functional array language with parallel semantics, and currently runs on Linux. APEX-generated code uses loop fusion and 'array contraction', special-case algorithms not generally available to interpreters (e.g., upgrade of permutation matrix/vector), to achieve a level of performance comparable to that of Fortran.

The APLNext VisualAPL system is a departure from a conventional APL system in that VisualAPL is a true .NET language which is fully interoperable with other .NET languages such as VB.NET and C#. VisualAPL is also object-oriented and Unicode-based. While it incorporates most of the features of standard APL implementations, the language extends standard APL to be .NET-compliant. VisualAPL is hosted in the standard Microsoft Visual Studio IDE and as such, invokes compiling in the same way as other .NET languages. By producing Common Intermediate Language (CIL) code, it uses the Microsoft just-in-time compiler (JIT) to support 32-bit or 64-bit hardware. Substantial performance speed-ups over standard APL have been reported,[citation needed] especially when (optional) strong typing of function arguments is used.

An APL-to-C# translator is available from Causeway Graphical Systems. This compiler is designed to allow APL code, translated to equivalent C#, to run fully outside of an APL environment. It requires a run-time library of array functions. Some speedup, sometimes dramatic, is visible, but is via optimisations occurring in the .NET Framework.

Standards[edit]

APL has been standardized by the American National Standards Institute (ANSI) working group X3J10 and International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), ISO/IEC Joint Technical Committee 1 Subcommittee 22 Working Group 3. The Core APL language is specified in ISO 8485:1989, and the Extended APL language is specified in ISO/IEC 13751:2001.

User groups and societies[edit]

Active[edit]

Filmography[edit]

Over the years APL has been the subject of more than a few films and videos. Some of these include:

  • "Chasing Men Who Stare at Arrays" Catherine Lathwell's Film Diaries; 2014, film synopsis – "people who accept significantly different ways of thinking, challenge the status quo and as a result, created an invention that subtly changes the world. And no one knows about it. And a Canadian started it all… I want everyone to know about it."[107]
  • "The Origins of APL – 1974 – YouTube", YouTube video, 2012, uploaded by Catherine Lathwell; a talk show style interview with the original developers of APL.[108]
  • "50 Years of APL", YouTube, 2009, by Graeme Robertson, uploaded by MindofZiggi, history of APL, quick introduction to APL, a powerful programming language currently finding new life due to its ability to create and implement systems, web-based or otherwise.[109]
  • "APL demonstration 1975", YouTube, 2013, uploaded by Imperial College London; 1975 live demonstration of the computer language APL (A Programming Language) by Professor Bob Spence, Imperial College London.[110]

See also[edit]

References[edit]

  1. ^ "Nested Arrays Research System – NARS2000: An Experimental APL Interpreter". NARS2000. Sudley Place Software. Retrieved 10 July 2015. 
  2. ^ "GNU APL". directory.fsf.org. Free Software Directory. Retrieved 28 September 2013. 
  3. ^ "VAX APL User's Guide" (PDF). bitsavers.org. Digital Equipment Corporation. 1991-04-30. Retrieved 2018-03-04. 
  4. ^ a b "A Bibliography of APL and J". Jsoftware.com. Retrieved 2010-02-03. 
  5. ^ a b "An Interview with Arthur Whitney". Kx Systems. 2004-01-04. Archived from the original on 2009-04-04. Retrieved 2010-02-03. 
  6. ^ a b Moler, Cleve. "The Growth of MATLAB" (PDF). Archived from the original (PDF) on 2009-04-11. Retrieved 2010-02-03. 
  7. ^ a b "About Q'Nial". Nial.com. Retrieved 2010-02-03. 
  8. ^ Rubinsteyn, Alex (2014). Runtime Compilation of Array-Oriented Python Programs (PDF) (Ph.D.). New York University. p. 30. APL directly inspired Speakeasy 
  9. ^ "Wolfram Language Q&A". Wolfram Research. Retrieved 2016-12-07. 
  10. ^ a b Iverson, Kenneth E. (1962). A Programming Language. Wiley. ISBN 0-471-43014-5. 
  11. ^ McIntyre, Donald B. (1991). "Language as an Intellectual Tool: From Hieroglyphics to APL". IBM Systems Journal. 30 (4): 554–581. doi:10.1147/sj.304.0554. Retrieved 9 January 2015. 
  12. ^ "ACM Award Citation – John Backus. 1977". Awards.acm.org. 1924-12-03. Retrieved 2010-02-03. 
  13. ^ Iverson, Kenneth E., "Automatic Data Processing: Chapter 6: A programming language" Archived 2009-06-04 at the Wayback Machine., 1960, Draft copy for Brooks and Iverson 1963 book, Automatic Data Processing.
  14. ^ Brooks, Fred; Iverson, Kenneth, (1963), Automatic Data Processing, John Wiley & Sons Inc.
  15. ^ "Turing Award Citation 1979". Awards.acm.org. Retrieved 2010-02-03. 
  16. ^ Hellerman, H., "Experimental Personalized Array Translator System", Communications of the ACM, 7, 433 (July, 1964).
  17. ^ Falkoff, Adin D.; Iverson, Kenneth E., "The Evolution of APL", ACM SIGPLAN Notices 13, 1978-08.
  18. ^ Abrams, Philip S., An interpreter for "Iverson notation", Technical Report: CS-TR-66-47, Department of Computer Science, Stanford University, August 1966;
  19. ^ Haigh, Thomas, "Biographies: Kenneth E. Iverson", IEEE Annals of the History of Computing, 2005
  20. ^ a b Breed, Larry, "The First APL Terminal Session", APL Quote Quad, Association for Computing Machinery, Volume 22, Number 1, September 1991, p.2-4.
  21. ^ Adin Falkoff – Computer History Museum. "Iverson credited him for choosing the name APL and the introduction of the IBM golf-ball typewriter with the replacement typehead, which provided the famous character set to represent programs."
  22. ^ Breed, Larry (August 2006). "How We Got to APL\1130". Vector (British APL Association). 22 (3). ISSN 0955-1433. 
  23. ^ APL\1130 Manual, May 1969
  24. ^ "Remembering APL". Quadibloc.com. Retrieved 2013-06-17. 
  25. ^ Falkoff, Adin; Iverson, Kenneth E., "APL\360 Users Guide", IBM Research, Thomas J. Watson Research Center, Yorktown Heights, NY, August 1968.
  26. ^ "APL\360 Terminal System", IBM Research, Thomas J. Watson Research Center, March 1967.
  27. ^ a b Pakin, Sandra (1968). APL\360 Reference Manual. Science Research Associates, Inc. ISBN 0-574-16135-X. 
  28. ^ Falkoff, Adin D.; Iverson, Kenneth E.,The Design of APL, IBM Journal of Research and Development, Volume 17, Number 4, July 1973. "These environmental defined functions were based on the use of still another class of functions—called "I-beams" because of the shape of the symbol used for them—which provide a more general facility for communication between APL programs and the less abstract parts of the system. The I-beam functions were first introduced by the system programmers to allow them to execute System/360 instructions from within APL programs, and thus use APL as a direct aid in their programming activity. The obvious convenience of functions of this kind, which appeared to be part of the language, led to the introduction of the monadic I-beam function for direct use by anyone. Various arguments to this function yielded information about the environment such as available space and time of day."
  29. ^ Minker, Jack (January 2004). "Beginning of Computing and Computer Sciences at the University of Maryland" (PDF). Section 2.3.4: University of Maryland. p. 38. Archived from the original (PDF) on 10 June 2011. Retrieved 23 May 2011. 
  30. ^ Stebbens, Alan. "How it all began". 
  31. ^ "SIGAPL". Sigapl.org. Retrieved 2013-06-17. 
  32. ^ Hui, Roger. "Remembering Ken Iverson". keiapl.org. KEIAPL. Retrieved 10 January 2015. 
  33. ^ ACM A.M. Turing Award. "Kenneth E. Iverson – Citation". amturing.acm.org. ACM. Retrieved 10 January 2015. 
  34. ^ ACM SIGPLAN. "APL2: The Early Years". www.sigapl.org. ACM. Retrieved 10 January 2015. 
  35. ^ Micro APL. "Overview of the APL System". www.microapl.co.uk. Micro APL. Retrieved 10 January 2015. 
  36. ^ Robertson, Graeme. "A Personal View of APL2010". archive.vector.org.uk. Vector – Journal of the British APL Association. Retrieved 10 January 2015. 
  37. ^ Rodriguez, P.; Rojas, J.; Alfonseca, M.; Burgos, J. I. (1989). "An Expert System in Chemical Synthesis written in APL2/PC". ACM SIGAPL APL Quote Quad. 19 (4): 299–303. doi:10.1145/75144.75185. Retrieved 10 January 2015. 
  38. ^ IBM. "APL2: A Programming Language for Problem Solving, Visualization and Database Access". www-03.ibm.com. IBM. Retrieved 10 January 2015. 
  39. ^ Falkoff, Adin D. (1991). "The IBM family of APL systems" (PDF). IBM Systems Journal. IBM. 30 (4): 416–432. doi:10.1147/sj.304.0416. Retrieved 2018-04-15. 
  40. ^ Texas Instruments (1977). "TI 745 full page ad: Introducing a New Set of Characters". Computerworld. 11 (27): 32. Retrieved 20 January 2015. 
  41. ^ Dyalog. "APL Fonts and Keyboards". www.dyalog.com. Dyalog. Retrieved 19 January 2015. 
  42. ^ Smith, Bob. "NARS2000 Keyboard". www.sudleyplace.com. Bob Smith / NARS2000. Retrieved 19 January 2015. 
  43. ^ MicroAPL Ltd. "Introduction to APL – APL Symbols". www.microapl.co.uk. MicroAPL Ltd. Retrieved 8 January 2015. 
  44. ^ Brown, James A.; Hawks, Brent; Trimble, Ray (1993). "Extending the APL character set". ACM SIGAPL APL Quote Quad. 24 (1): 41–46. doi:10.1145/166198.166203. Retrieved 8 January 2015. 
  45. ^ Kromberg, Morten. "Unicode Support for APL". archive.vector.org.uk. Vector, Journal of the British APL Association. Retrieved 8 January 2015. 
  46. ^ Hsu, Aaron. "Computer Science Outreach and Education with APL". Dyalog, Ltd. Retrieved 15 July 2016. 
  47. ^ Dyalog, Inc. APL fonts and keyboards. http://www.dyalog.com/apl-font-keyboard.htm
  48. ^ a b MicroAPL. "Operators". www.microapl.co.uk. MicroAPL. Retrieved 12 January 2015. 
  49. ^ Primitive Functions. "Primitive Functions". www.microapl.co.uk/. Retrieved 1 January 2015. 
  50. ^ Workspace. "The Workspace". www.microapl.co.uk. Retrieved 1 January 2015. 
  51. ^ "example". Catpad.net. Archived from the original on 2013-07-08. Retrieved 2013-06-17. 
  52. ^ APL Symbols. "Entering APL Symbols". www.microapl.co.uk. Retrieved 1 January 2015. 
  53. ^ Dickey, Lee, A list of APL Transliteration Schemes, 1993
  54. ^ Iverson K.E., "Notation as a Tool of Thought", Communications of the ACM, 23: 444-465 (August 1980).
  55. ^ Batenburg. "APL Efficiency". www.ekevanbatenburg.nl. Retrieved 1 January 2015. 
  56. ^ Vaxman. "APL Great Programming" (PDF). www.vaxman.de. Retrieved 1 January 2015. 
  57. ^ Janko, Wolfgang (May 1987). "Investigation into the efficiency of using APL for the programming of an inference machine". ACM Digital Library. 17 (4): 450–456. doi:10.1145/384282.28372. Retrieved 1 January 2015. 
  58. ^ Borealis. "Why APL?". www.aplborealis.com. Retrieved 1 January 2015. 
  59. ^ Iverson, Kenneth E. "A Dictionary of APL". www.jsoftware.com. JSoftware; Iverson Estate. Retrieved 20 January 2015. 
  60. ^ a b c d e f "APL concepts". Microapl.co.uk. Retrieved 2010-02-03. 
  61. ^ "Nested array theory". Nial.com. Retrieved 2010-02-03. 
  62. ^ a b c "Programmera i APL", Bohman, Fröberg, Studentlitteratur, ISBN 91-44-13162-3
  63. ^ Iverson, Kenneth E. "APL Syntax and Semantics". www.jsoftware.com. I. P. Sharp Associates. Retrieved 11 January 2015. 
  64. ^ Dyalog APL/W. "Producing a standalone 'Hello World' program in APL". www.youtube.com. Dyalog-APLtrainer. Retrieved 11 January 2015. 
  65. ^ MicroAPL. "APL Primitives". www.microapl.co.uk. MicroAPL. Retrieved 11 January 2015. 
  66. ^ NARS2000. "APL Font – Extra APL Glyphs". wiki.nars2000.org. NARS2000. Retrieved 11 January 2015. 
  67. ^ Fox, Ralph L. "Systematically Random Numbers". www.sigapl.org. SIGAPL. Retrieved 11 January 2015. 
  68. ^ SIGAPL. "What is APL?". www.sigapl.org. SIGAPL. Retrieved 20 January 2015. 
  69. ^ Ju, Dz-Ching; Ching, Wai-Mee (1991). "Exploitation of APL data parallelism on a shared-memory MIMD machine". Newsletter ACM SIGPLAN Notices. 26 (7): 61–72. doi:10.1145/109625.109633. Retrieved 20 January 2015. 
  70. ^ Hsu, Aaron W.; Bowman, William J. "Revisiting APL in the Modern Era" (PDF). www.cs.princeton.edu. Indiana University / Princeton. Retrieved 20 January 2015. 
  71. ^ Ching, W.-M.; Ju, D. (1991). "Execution of automatically parallelized APL programs on RP3". IBM Journal of Research & Development. 35 (5/6): 767–777. doi:10.1147/rd.355.0767. Retrieved 20 January 2015. 
  72. ^ Blelloch, Guy E.; Sabot, Gary W. "Compiling Collection-Oriented Languages onto Massively Parallel Computers". Carnegie Mellon University / Thinking Machines Corp.: 1–31. CiteSeerX 10.1.1.51.5088Freely accessible. Collection oriented languages include APL, APL2 
  73. ^ Jendrsczok, Johannes; Hoffmann, Rolf; Ediger, Patrick; Keller, Jörg. "Implementing APL-like data parallel functions on a GCA machine" (PDF). www.fernuni-hagen.de. Fernuni-Hagen.De. pp. 1–6. Retrieved 22 January 2015. GCA – Global Cellular Automation. Inherently massively parallel. 'APL has been chosen because of the ability to express matrix and vector' structures. 
  74. ^ Brenner of IBM T.J.Watson Research Center, Norman (1984). "VLSI circuit design using APL with fortran subroutines". ACM SIGAPL APL Quote Quad. ACM SIGAPL. 14 (4): 77–79. doi:10.1145/800058.801079. ISBN 0897911377. Retrieved 22 January 2015. APL for interactiveness and ease of coding 
  75. ^ Gamble, D.J.; Hobson, R.F. (1989). "Towards a graphics/procedural environment for constructing VLSI module generators". Communications, Computers and Signal Processing, 1989. Conference Proceeding., IEEE Pacific Rim Conference on. Victoria, BC, Canada: IEEE: 606–611. doi:10.1109/PACRIM.1989.48437. VLSI module generators are described. APL and C, as examples of interpreted and compiled languages, can be interfaced to an advanced graphics display 
  76. ^ MARTHA and LLAMA. "The APL Computer Language". marthallama.org. MarthaLlama. Retrieved 20 January 2015. 
  77. ^ Lee, Robert S. (1983). "Two Implementations of APL". PC Magazine. 2 (5): 379. Retrieved 20 January 2015. 
  78. ^ a b "2017 Annual Report" (PDF). SimCorp. 2018-02-01. Retrieved 2018-04-03. Sofia is a front-to-back investment management platform like SimCorp Dimension. ... Sofia is based on the APL coding language just like some parts of SimCorp Dimension. 
  79. ^ Lee, Georges; Lelouche, Ruddy; Meissonnier, Vincent; Zarri, Gian Piero (1 September 1982). "Using APL in an Artificial Intelligence environment". ACM SIGAPL APL Quote Quad. 13 (1): 183–191. doi:10.1145/390006.802242. Retrieved 2018-04-03. 
  80. ^ Fordyce, K.; Sullivan, G. (1985). "Artificial Intelligence Development Aids". APL Quote Quad. APL 85 Conf. Proc. (15): 106–113. doi:10.1145/255315.255347. 
  81. ^ Alfonseca, Manuel (July 1990). "Neural networks in APL". ACM SIGAPL APL Quote Quad. 20 (4): 2–6. doi:10.1145/97811.97816. Retrieved 2018-04-03. 
  82. ^ Kromberg, Morten. "Robot Programming in APL". www.dyalog.com/. Retrieved 6 January 2015. 
  83. ^ Holmes, W N (May 1978). "Is APL a Programming Language?". The Computer Journal. 21 (2): 128–131. doi:10.1093/comjnl/21.2.128. Retrieved 2018-04-07. 
  84. ^ Hsu, Aaron (2017-11-18). "Design Patterns vs. Anti-pattern in APL". functionalconf.com. Retrieved 2018-04-07. 
  85. ^ Magnenat-Thalmann, Nadia; Thalmann, Daniel (1985). Computer Animation Theory and Practice. Springer-Verlag. p. 38. ISBN 9784431684336. Retrieved 2018-04-03. Digital Effects is another production house that worked on Tron. They used a laser-scanning system to digitize, store and reproduce images. Judson Rosebush, president of Digital Effects, is the primary designer of APL VISION and FORTRAN VISION, two computer animation packages that are currently used. 
  86. ^ Gutsell, Sam (2017-10-17). "Stormwind Simulator at Dyalog '16". www.optima-systems.co.uk. Optima Systems. Retrieved 2018-04-03. Stormwind is a [3D boating simulator] that has gained a huge amount of interest in the APL community. 
  87. ^ "OP-Pohjola ja Tieto hoitivat sovelluksen muutostyöt sujuvalla yhteistyöllä" [Smooth cooperation between OP-Pohjola and Tieto enabled app modification] (PDF). www.tieto.com (in Finnish). Tieto. Retrieved 2018-04-03. 
  88. ^ "Vi idag" [We today]. profdoccare.se (in Swedish). Retrieved 2018-04-03. Through the choice of APL as a technical platform, it is relatively easy to quickly build a solution that can be called a executable prototype (translated from the original) 
  89. ^ Brenner, Charles. "DNA Identification Technology and APL". dna-view.com. Presentation at the 2005 APL User Conference. Retrieved 9 January 2015. 
  90. ^ Brenner, Charles. "There's DNA Everywhere – an Opportunity for APL". www.youtube.com. YouTube. Retrieved 9 January 2015. 
  91. ^ "Tips for golfing in APL". stackexchange.com. Retrieved 2018-04-03. 
  92. ^ "VideoBrain Family Computer", Popular Science, November 1978, advertisement.
  93. ^ Higgins, Donald S., "PC/370 virtual machine", ACM SIGSMALL/PC Notes, Volume 11, Issue 3 (August 1985), pp.23 – 28, 1985.
  94. ^ "Yahoo! Group APL-L". April 2003. 
  95. ^ Zaks, Rodnay, "A Microprogrammed APL Implementation,", Ph.D. Thesis, University of California, Berkeley, June 1972.
  96. ^ Zaks, Rodnay, "Microprogrammed APL,", Fifth IEEE Computer Conference Proceedings, Sep. 1971 p 193
  97. ^ Yerazunis, William. "A Partial Implementation of APL with Graphics Primitives for Prime Computers". Retrieved 2013-08-14. 
  98. ^ "Dyalog Ltd's website". 
  99. ^ "APLX has been withdrawn from commercial sale but can be downloaded free of charge". Microapl.com. Retrieved 25 October 2016. 
  100. ^ Weigang, Jim (May 1985). "An Introduction to STSC's APL Compiler". APL Quote Quad. APL85 Conference. 15. ACM. 
  101. ^ "APL Compiler (message from Jim Weigang to the comp.lang.apl Newsgroup)". 5 Apr 1994. 
  102. ^ Budd, Timothy (1988). An APL Compiler. Springer-Verlag. ISBN 0-387-96643-9. 
  103. ^ "FTP area for Associate Professor Timothy A. Budd". 
  104. ^ Sirlin, Samuel W. "The APL c compiler project". 
  105. ^ Song, Yonghong; Xu, Rong; Wang, Cheng; Li, Zhiyuan. "Improving Data Locality by Array Contraction" (PDF). Purdue University. Retrieved 4 February 2015. Array contraction is a program transformation which reduces array size while preserving the correct output. In this paper, we present an aggressive array-contraction technique and study its impact on memory system performance. This technique, called controlled SFC, combines loop shifting and controlled loop fusion to maximize opportunities for array contraction within a given loop nesting. A controlled fusion scheme is used 
  106. ^ "The APEX Project". 
  107. ^ Lathwell, Catherine. "Chasing Men Who Stare at Arrays". www.aprogramminglanguage.com/. Catherine Lathwell. Retrieved 8 January 2015. 
  108. ^ Lathwell, Catherine. "The Origins of APL – 1974 – YouTube". www.youtube.com. Catherine Lathwell on YouTube. Retrieved 8 January 2015. 
  109. ^ Robertson, Graeme. "50 Years of APL – Video". www.youtube.com. Graeme Robertson/YouTube. Retrieved 8 January 2015. 
  110. ^ Spence, Bob. "APL demonstration 1975". www.youtube.com. Imperial College London. Retrieved 8 January 2015. 

Further reading[edit]

External links[edit]