# Ghost Writing: Text, Arrays, Randomness

<p align="center">
<img src="https://git.le-club-des-sans-sujets.org/gauthiier/Revisiting-Concepts-Notations-Software-Art/media/branch/main/img/love-letter.png" width="80%"/>	
</p>

## Sketch: 2.0 Array + Index

```javascript
// Array + Index!

var NAMES = ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaike"];
var INDEX = 0;
    
function setup() {
  createCanvas(400, 400);
}

function draw() {
  background(220);
}

function keyTyped() {
  if(key == 'x') {
    print("Hi " + NAMES[0] + "!");
  }
}

// Reference: https://p5js.org/reference/
```

### 🤔 What are indices?

```javascript
 ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaikke"]  <--- Array (var NAMES)
     |        |         |        |         |        |
     0        1         2        3         4        5		<--- indices (var INDEX)
```

### 📚 Exercise

1. Modify sketch 2.0 so that:
* When key ```'k'``` is typed then ```"Hi Karin!"``` is printed on the console
* When key ```'s'``` is typed then ```"Hi Sigrid!"``` is printed on the console
* When key ```'n'``` is typed then ```"Hi Nanna!"``` is printed on the console
* When key ```'m'``` is typed then ```"Hi Maaike!"``` is printed on the console

2. Modify sketch 2.0 so that:
* Every time key ```'x'``` is typed then print the name of the following person in the array (```"Hi David!"```, ```"Hi Karin!"```, ```"Hi Sigrid!"```, and so forth)

### 🤔 Who/what is "undefined"?

<p align="center">
<img src="https://git.le-club-des-sans-sujets.org/gauthiier/Revisiting-Concepts-Notations-Software-Art/media/branch/main/img/undefined.png">	
</p>

## Sketch: 2.1 Array + Index + Loop

```javascript
// Array + Index + Loop!

var NAMES = ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaike"];
var ACTIVITIES = ["piano", "tennis", "chess", "records"];
var INDEX = 0;
    
function setup() {
  createCanvas(400, 400);
}

function draw() {
  background(220);
}

function keyTyped() {
  if(key == 'x') {
    for(let i = 0; i < ACTIVITIES.length; i++) {
      print(NAMES[INDEX] + " likes to play " + ACTIVITIES[i]);  
    }
  }
}

// Reference: https://p5js.org/reference/
```

### 🤔 How do for-loops work?

```javascript
for(let i = 0; i < X; i++) {
  // do_somethings();
}
```
where

```javascript
let i = 0 
// is the declaration and initialisation of the control variable (i)

i < X 
//is the loop continuation condition: if the condition is true, the statement in the loop [do_something();] is executed, otherwise exit the loop when the condition is false

i++
//is the incremental (update) statement that is executed at the end of the loop (i.e. just after the loop statement [do_something();] as been executed) 
```

### 📚 Exercise

1. Modify skecth 2.1 so that every one listed in the ```NAMES``` array have all the activities listed in the ```ACTIVITIES``` array be printed out on the console when key ```'x'``` is typed (this is called a nested loop!). The console output should look something like:

```
Karin likes to play piano 
Karin likes to play tennis 
Karin likes to play chess 
Karin likes to play records 
Sigrid likes to play piano 
Sigrid likes to play tennis 
Sigrid likes to play chess 
Sigrid likes to play records 
Nanna likes to play piano 
Nanna likes to play tennis 
Nanna likes to play chess 
(etc.)
```

## Sketch: 2.2 Array + Index + Randomness

Randomness in p5js is based on generating a random number between 0 and a specified maximum. 

Typically a random number is produced with the ```random``` function: 
```javascript
random(X); // generates a random number between 0 and X
````
Here is an example:
```javascript
let random_number = random(10); // assign a random number between 0 and 10 to variable random_number
````

Rudimentary indeed, but there are many things we can build with this simple function!

### 🤔 How to select a random element in an array?

Since we access elements of an array with indices, we can generate a random index between 0 and the length of an array so to select a random element in it.

The first problem we have to solve is that the ```random``` functions generates a "real" number (ex: 4.993319470244624, 1.9486631456631776, 7.1841821754535813, etc.) while the indices of an array are "integer" numbers (5, 2, 7, etc.). 

We thus need to round the "real" numbers produced by random (4.993319470244624 -> 5, 1.9486631456631776 -> 2, 7.1841821754535813 -> 7). We do this with the ```floor``` function:

```javascript
let random_number = floor(random(10)); // assign a random integer number between 0 and 10 to variable random_number
````

With this "fix" we can generate a random index (integer) between 0 and the length of a given array.

```javascript
var NAMES = ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaike"];

let random_index_names = floor(random(NAMES.length));

print(NAMES[random_index_names]);
````

This will indeed print a random name in the array ```NAMES``` each time it is executed. 

But what if we would like to print a random activity from the ```ACTIVITIES``` array as well? 

```javascript
var NAMES = ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaike"];
var ACTIVITIES = ["piano", "tennis", "chess", "records"];

let random_index_names = floor(random(NAMES.length));
let random_index_activities = floor(random(ACTIVITIES.length));

print(NAMES[random_index_names] + " likes to play " +  ACTIVITIES[random_index_activities]);
````

This will work, but it is not "elegant"... We have here two variables (```random_index_names```, ```random_index_activities```) that are assigned a random value with the respective arrays' length (```NAMES.length```, ```ACTIVITIES.length```). What if we had many arrays? We would need as many variables as there are arrays to select from right? The code would be very long!

To remediate this tedious need to write too much code, how about writing a function that selects a random element from an "generic" array? 

Here is an example of a custom "choice" function taking an array as input and returns a randomly selected elements from the array:

```javascript
// function selecting a random element from an array
function choice(array_to_choose_from) {
	let random_index = floor(random(array_to_choose_from.length));
	return array_to_choose_from[random_index];
}
````



```javascript
// Array + Index + Randomness!

var NAMES = ["David", "Karin", "Sigrid", "Nanna", "Laura", "Maaike"];
var ACTIVITIES = ["piano", "tennis", "chess", "records"];
    
function setup() {
  createCanvas(400, 400);
}

function draw() {
  background(220);
}

// function selecting a random element from an array
function choice(array_to_choose_from) {
	let random_index = floor(random(array_to_choose_from.length));
	return array_to_choose_from[random_index];
}

function keyTyped() {
  if(key == 'x') {
    print(choice(NAMES) + " likes to play " + choice(ACTIVITIES) + " with " + choice(NAMES));
  }
}

// Reference: https://p5js.org/reference/
````

### 📚 Exercise

1. Modify sketch 2.2 by adding a day of the week when an activity is taking place. For example: 

```
David likes to play records with Karin on Tuesday
```

2. Come up with your own random sentences! Remember you can add as many arrays to select from as you want and most languages are structured "systems" having nouns, verb, adjectives, adverbs, etc. Here is what I came up with (can you guess what my code looks like?):

```
Laura wears a blue sweater when Sigrid plays tennis 
Karin wears a black cap when Karin plays records 
Laura wears a expensive scarf when Karin plays records  
Karin wears a yellow jacket when Sigrid plays chess 
David wears a ridiculous scarf when Sigrid plays records
Karin wears a black jacket when Maaike plays chess 
```

## ✍️ Christopher Strachey's Love Letters

<p align="center">
<img src="https://git.le-club-des-sans-sujets.org/gauthiier/Revisiting-Concepts-Notations-Software-Art/media/branch/main/img/Strachey-Mark1.png" width="100%"/>	
</p>

So now that we have a better understanding of how arrays, indices, randomness, and functions work, let's write love letters!

One of the first non-scientific computer program that was ever written is Christopher Strachey's Love Letters program for the Manchester Mark I (so called [Baby](https://content.presspage.com/uploads/1369/1920_themanchestermk1computerbuiltbyextendingthebaby.jpg?10000)). In fact, this computer program (written in 1952 and making use of randomness) is arguably the first art-inspired program! Christopher Strachey was a computer programming pioneer who worked along Alan Turing in the very early days of computing at the University of Manchester. Strachey's story is fascinating. There is a great article about [him and the love letters on Rhizome's Queer History of Computing written by Jacob Gaboury](https://rhizome.org/editorial/2013/apr/9/queer-history-computing-part-three/). For those who are interested in researching Strachey's work, please have a look at his [papers and correspondences at the Bodleain library's archive](https://archives.bodleian.ox.ac.uk/repositories/2/resources/2561).

Strachey's Love Letters have been studied before. [David Link](http://www.alpha60.de) did a colossal reconstitution of the Love Letter program on a simulator of the Manchester Mark computer. [The works was exhibited circa 2010](http://www.alpha60.de/art/love_letters/). The program doesn't look at all like the code we are writing at the moment! The picture on the right side above (☝️) is from Link's simulator. Early computers did not have the compilers and interpreters we have now (remember compilers and interpreters) and thus the code was written in a rather cryptic way (believe me, way more cryptic than what we are writing). 

The program we are about to write in a "modern" computing language (i.e. javascript/p5js) is a modified version of [Nick Montfort](https://nickm.com)'s letter.py source code written in python. Montfort's letter.py was based on Noah Wardrip-Fruin's article ["Digital Media Archaeology."](https://www.degruyter.com/document/doi/10.1525/9780520948518-016/html)


### An Archaeology of Love Letters' structure

First, let's have a look at love letters to see what they look like. David Link has generated an [archive of simulated letters](http://www.alpha60.de/art/love_letters/archive/muc/). 

Here are four examples: 

``` 
HONEY MOPPET
        YOU ARE MY AMOROUS RAPTURE.: MY KEEN LOVE. MY COVETOUS
 INFATUATION THIRSTS FOR YOUR FERVENT LIKING. YOU ARE MY
 CRAVING LIKING. MY CURIOUS RAPTURE FONDLY THIRSTS FOR YOUR
 ANXIOUS ENCHANTMENT.
                             YOURS COVETOUSLY
MUC
```

```
DEAR DARLING
        MY ADORABLE FELLOW FEELING WANTS YOUR SWEET INFATUATION
. MY ADORABLE ARDOUR LOVINGLY WISHES YOUR FERVOUR. MY
 UNSATISFIED FELLOW FEELING EAGERLY HUNGERS FOR YOUR IMPATIENT
 DESIRE. YOU ARE MY LOVING FERVOUR. MY WINNING WISH YEARNS FOR YOUR
 KEEN HEART.
                             YOURS FERVENTLY
MUC
```

```
HONEY HONEY
        MY BURNING FANCY EAGERLY TEMPTS YOUR INFATUATION.
 YOU ARE MY FERVENT YEARNING. MY LIKING BEAUTIFULLY YEARNS FOR YOUR
 LOVE. MY APPETITE TENDERLY CHERISHES YOUR BEAUTIFUL WISH.
 YOU ARE MY EROTIC ADORATION.
                             YOURS SEDUCTIVELY
MUC
```

```
DARLING LOVE
        YOU ARE MY AMOROUS ENCHANTMENT.: MY KEEN EAGERNESS.
 YOU ARE MY DEVOTED ENCHANTMENT. MY YEARNING FERVENTLY LIKES
 YOUR AMOROUS PASSION. MY EAGERNESS TENDERLY YEARNS FOR YOUR
 PASSION.
                             YOURS ARDENTLY
MUC
```

Can you decipher certain writing patterns in the above formulations? If so, what are they?

Consider this sentence:

```
MY YEARNING FERVENTLY LIKES YOUR AMOROUS PASSION.
```

We can "code" this sentence as follow:

```determiner``` + ```noun``` + ```adverb``` + ```verb``` + ```determiner``` + ```adjective``` + ```noun``` + .

Now consider this sentence, whose structure seems to come up often:

```
YOU ARE MY AMOROUS RAPTURE.
```

Let's "code" this like:

YOU ARE MY + ```adjective``` + ```noun``` + .

There is also this small phrase:

```
MY KEEN EAGERNESS.
```

Which can be coded as:

MY + ```adjective``` + ```noun``` + .

So we have two types of sentences: 
* long form: ```determiner``` + ```noun``` + ```adverb``` + ```verb``` + ```determiner``` + ```adjective``` + ```noun``` + . 
* short form: YOU ARE MY + ```adjective``` + ```noun``` + . OR MY + ```adjective``` + ```noun``` + .

In terms of sentences sequencing we notice that: 
1. the short form MY + ```adjective``` + ```noun``` + . always follows the other short form YOU ARE MY + ```adjective``` + ```noun``` + . This short form never follows the long form.
2. short form YOU ARE MY + ```adjective``` + ```noun``` + . is never followed by the same short form YOU ARE MY + ```adjective``` + ```noun``` + .



"determiner + adjective + noun + adverb + verb + determiner + adjective + noun". Based on this, as an example, your script could output a sentence such as the following: "MY SWEET LONGING BREATHLESSLY ADORES YOUR ANXIOUS WISH". Furthermore, your script should allow for variations of this sentence structure, that is, exclude (or not) certain components depending on randomness and yet keep the sentence grammatically correct. For example the sentence above could become: "MY SWEET LONGING ADORES YOUR WISH".