# Notes on the APL programming language

As stated before, I have a fetish for unconventional programming languages. I recently came across APL (acronym for “a programming language”), which is both unconventional and mind-blowing in a sense.

It was originally intended to be a mathematical notation for manipulating arrays, but just like Lisp it ended up being a programming language when IBM implemented it in the late 60s.

Even-thought APL is still very much alive, hiding in dusty corners of banking-software code-basis out there, I think it’s fair to say it has fell out of fashion. However, there’s still a lot of value in learning it.

For starters, APL was hugely influential in the design of languages such as C++, MATLAB or Python. It’s creator, Kenneth E. Iverson even won a Turing Award for his work in APL. APL is indeed a relic of the past, but it’s vector-based semantics can still teach us new ways to understand computation and it’s historical value is unquestionable. As Perlis once said,

A language that doesn’t affect the way you think about programming, is not worth knowing.

and I assure you APL
**will affect the way you think about programming**.

## The Language

The first thing you need to know about APL is that it’s syntax
has multiple mathematical symbols, such as
`←`

for assignment and
`⍝`

for comments. This makes it a pain to
program in, since you have to keep copying and pasting obscure Unicode
characters around to get anything done. It also makes APL very hard to
read — let’s just say APL code is
*quite concise*.

The only data structure APL supports is the vector (i.e. nonempty
arrays of numbers). Vectors can be be written inline or constructed
with the iota (`⍳`

) operator, which returns
a vector of indices:

```
⍝ Inline vector
1 6 3 ⍝ Outputs 1 6 3
⍝ Vector of indices
⍳5 ⍝ Outputs 1 2 3 4 5
```

Vectors can be folded with the `/`

operator,
which takes a binary operator and a list:

```
⍝ Computes the sum of the integers between 1 and 5.
+/⍳5 ⍝ Outputs 15
```

Vectors of the same length can be combined with any binary operation (which works like zip-with):

```
⍝ Adding two vectors
1 3 5+2 4 6 ⍝ Outputs 3 7 11
```

Likewise, unary operators can be applied to vectors:

```
⍝ Vector of multiplicative inverses
÷1 3 5 ⍝ Outputs 1 0.3333333333 0.2
```

This is about everything you need to know about
APL — as far as I can tell, having programmed in it
for about 2 hours. APL supports some other fun stuff, such as custom
monadic (single argument) and dyadic (two arguments) operators,
lambdas (anonymous functions) and mapping constructs (the “over-each”
or `¨`

operator), but I believe I’ve covered the bulk of it in here.

## Learning & Using APL

Most of my knowlodge about APL comes from
the Wikipedia page on APL syntax. I’d recommend starting with that. You could also read
the original paper on APL
and
*A Practical Introduction to APL 1 & APL 2*.

If you want to run APL code in your machine I’d suggest using GNU APL, which is a free & open-source interpreter.