Of all the many programming languages, none has quite caught my attention like the “Iversonian” programming languages, that is, languages like APL, Shakti, Ivy, BQN and J - the subject of this blog post.

One misconception is that languages like J are in the same caliber as Brain F**k and other esoteric or golfing languages which are mostly for recreational programming. Languages like J however were designed to be a replacement to traditional maths notation - an interface for thinking or a tool of thought as their inventor Kenneth E. Iverson called them in his Turing Award lecture.

In this blog post I am going to introduce the J programming language by using it as a “tool of thought” to explain the 1 dimensional random walk.

To try out the code yourself you will have to install the J interpreter. The easiest way to get it working on Mac is through running the brew formula `brew install --cask j`

. For other platforms,
see the installation instructions.

## First, a random walk in 5 lines.

The 1 dimensional random walk is a toy model used in finance for creating what may look like stock market prices. In it’s simplest form, a 1 dimensional random walk consists of;

- Several steps (a list of values), and at each step (for each value) it is either up (indicated by
`-1`

) or down (indicated by`+1`

). - Note that the value of each step
`-1`

or`+1`

is chosen at random. Hence the term ‘random walk’. So a random walk is basically a list of`-1`

and`+1`

generated at random. - To attain the ‘synthetic price’ or what looks like stock prices, we simply compute the running sum of this list of random
`-1`

and`+1`

integers.

The entire toy model of prices we described above is created using the J code below. Let me describe how.

```
load 'plot' NB. Import the utility for plotting charts
indices =: ? 100#2 NB. Generate indices
walks =: indices { _1 1 NB. Use indices to create list of -1 & +1 integers
running_sum =: +/\ walks NB. Compute synthetic price
plot running_sum NB. Plot the running sum
```

### Generating indices.

An index refers to the position of an item in a list. For example, the list `1 2 3 4`

has the indices `0`

for `1`

, `2`

, `3`

, with the index `0`

referring to `1`

, the index `1`

referring to `2`

, the index `2`

referring to `3`

and the index `3`

referring to `4`

.

Line 2, `indices =: ? 100#2`

generates indices as follows.
The `#`

symbol takes in two values `2`

and `100`

and what it does is that it “copies” `2`

into an list `100`

times. For example `5#1`

copies `1`

five times to give `1 1 1 1 1`

. So `100#2`

returns `2 2 2 2 2 2 2 2 2 2 ... 2`

up to the 100’th `2`

.

The `?`

symbol generates random numbers, you can think of it as rolling a dice. For example, `? 5`

may randomly return `0`

, `1`

, `2`

, `3`

or `4`

. So `? 5`

can be read as “generate a random number below 5”, `0`

is included since the values `?`

generates are always greater than or equal to `0`

.

And finally to generate a list of random numbers, we simply give `?`

a list of numbers for example `? 3 3 3 3 3`

may generate `1 1 0 2 2`

i.e 5 random numbers under `3`

.
Recall that in line 2, `100#2`

generates a list of one hundred `2`

’s. `?`

then takes the list of one hundred `2`

’s and for each `2`

it generates a random number less than `2`

i.e `0`

or `1`

.

`? 100#2`

can be read as “generate a list one hundred 2’s and for each item in the list, generate a random integer less that 2”. This will return a random list of 100 items made up of exclusively 1’s and 0’s looking like `0 0 1 1 0 0 1 1 1 0 0 1 0 1 0 1 1 0 1 0 1 1 0 1 ...`

. We then store this in a variable called `indices`

using `=:`

This is what we shall use as our indices.

### Use indices to create list of -1 & +1 integers.

In line 3, we use our list of 0’s and 1’s as indices to generate a random walk (random list made up of -1’s & +1’s).
To do this, we use the symbol `{`

in `indices { _1 1`

that takes in two sets of values, first is the variable `indices`

which is a list of randomly generated 1’s & 0’s. On the other side of `{`

is `_1 1`

, which represent the directions of our random walk `_1`

for `-1`

(down) and `1`

for `+1`

or (up).

What `{`

does is that it “pulls” items from a list given an index.
The list `_1 1`

has the indices `0`

for `_1`

and `1`

for `1`

, recall that an index refers to the position of an item in the list. So the statement `0 { _1 1`

would return `_1`

and `1 { _1 1`

returns `1`

from the list.

A list of indices would also return a list of items, for instance `1 0 0 1 { _1 1`

would return `1 _1 _1 1`

. Which is similar to what `indices { _1 1`

is doing. Since `indices`

is a list of random one hundred 1’s and 0’s it will also randomly pull out a list of `_1`

and `1`

thus giving us a list like `_1 _1 1 1 _1 _1 _1 _1 _1 _1 1 _1 ...`

up to the one hundredth index. Which is the random walk of 100 steps.

We also store this list into a variable `walks`

using `=:`

.

### Compute the synthetic prices.

In line 4 we use `+/\`

the running sum of the random walk. For example `+/\ 1 1 1 1 1 1 1`

computes the running sum of seven 1’s, which gives us `1 2 3 4 5 6 7`

. Which is exactly what we do with `+/\ walks`

.

Since `walks`

is made up of randomly generated `_1`

and `1`

, it’s running sum will equally fluctuate up and down. The running sum of `1 _1 1 _1 _1 _1 1 1 1 _1 _1`

will look like `1 0 1 0 _1 _2 _1 0 1 0 _1`

The running sum (synthetic price) `+/\ walks`

is then stored inside the variable `running_sum`

with `=:`

## A random walk in 2 lines.

This post was supposed how to create a random walk in 2 lines of J. So below is the exact code above refactored to run in two lines.

```
load 'plot' NB. Import the plot library
plot +/\ (?100#2) { _1 1 NB. Plot synthetic price/ random walk
```

### Adjusting step size

`100`

denotes the number of steps the random walk takes. The more the steps the closer to actual stock prices the plot will look like.

#### Random Walk of 100 steps

#### Random Walk of 200 steps

#### Random Walk of 500 steps

#### Random Walk of 1,000 steps

#### Random Walk of 10,000 steps