The Author Becomes an Algorithm

From Early Computer Poetry to Generative Writing

1. The Love Letter Written by Nobody

Imagine a young computer programmer standing beside a machine the size of a room.

It is the early 1950s.

The computer contains thousands of electronic components. It requires specialist attention, consumes considerable electricity and occupies space that could accommodate several desks.

Its principal purpose is calculation.

Scientists and engineers are interested in using such machines to solve mathematical problems, analyse numerical data and perform operations that would otherwise require enormous amounts of human labour.

But the programmer has another idea.

What if the machine could write a love letter?

Not calculate the cost of posting one.

Not print a letter that somebody else has already composed.

Actually construct a new message from a collection of words and phrases.

The programmer prepares lists of affectionate expressions.

There are greetings, adjectives, nouns and concluding phrases.

The computer is instructed to select from the lists and assemble the selections into sentences.

Eventually, a message appears.

It addresses an imaginary beloved.

Its language is extravagant.

Its sentiments seem oddly artificial, as though someone has learned the vocabulary of romance without quite understanding how people fall in love.

The result is both comic and unsettling.

A machine designed to perform calculations has produced something recognisable as a love letter.

But who wrote it?

The programmer supplied the vocabulary.

The programmer designed the rules.

The computer selected and assembled the words.

No human being necessarily chose that particular combination.

This is not merely an invented scene.

In 1952, Christopher Strachey developed a love-letter-generating program for the Manchester computer.

A Centre for Scientific Archives catalogue lists the love-letter program under 1952. Oxford's Strachey exhibition booklet identifies the Strachey archive with the Bodleian Library; the catalogue's availability online should not be confused with the papers' custody.

Strachey's experiment is among the earliest documented examples of literary text generation using an electronic computer.

It occupies an important position in the history of computational writing.

An electronic machine could now perform the combinatorial work that earlier writers had carried out manually or built into physical devices.

The words remained human inventions.

The rules remained human designs.

But the final selection and arrangement could be delegated to the computer.

A new participant had entered the literary process.

Not necessarily a conscious author.

Not necessarily a creative intelligence.

But a machine capable of producing texts that its programmer had not individually written.

The author had begun to design a procedure rather than compose every output.

A logic board from a Ferranti Mark I computer, 1951. Credit: Ferranti Limited. Source. CC BY-SA 4.0. Resized; no crop.

2. Christopher Strachey and the Manchester Computer

Christopher Strachey was a British computer scientist whose work contributed to the development of programming languages and their mathematical foundations.

He belonged to the generation that encountered electronic computing while the field was still being established.

Modern programmers inherit programming languages, operating systems, documentation and development tools built over many decades.

Strachey's generation worked much closer to the machinery.

Programming was difficult, experimental and frequently tied to the characteristics of a particular computer.

Strachey became acquainted with Alan Turing and worked with computing equipment at Manchester.

In 1952, he developed a program that generated love letters.

The program selected words and phrases from predefined collections and combined them according to grammatical patterns.

The resulting messages resembled exaggerated romantic correspondence.

Their emotional vocabulary was rich.

Their individual combinations could be absurd.

A later account by Strachey, The "Thinking" Machine, appeared in the October 1954 issue of Encounter and included an example of machine-generated correspondence. His original working papers identify the earlier 1952 program.

These dates should be distinguished.

1952 refers to the development of the love-letter program.

1954 refers to Strachey's published discussion of the machine and an example of its output.

The two events are connected, but they are not identical.

A machine performing romance

Why generate love letters?

The choice was humorous, but it also made a serious point.

Romantic language is associated with sincerity, emotion and personal expression.

A love letter normally appears to communicate something about the writer's inner life.

If a computer can produce convincing romantic phrases by following rules, what does that imply?

It certainly demonstrates that some surface features of emotional language can be generated mechanically.

It does not establish that the computer experiences affection.

Nor does it prove that human emotions are merely computational routines.

Those would be much stronger philosophical claims.

The program could produce expressions of love without loving anyone.

This distinction anticipates later debates about artificial intelligence and language generation.

A system can produce text that readers interpret emotionally even when the mechanism generating that text has no demonstrated emotional experience.

The comic effect

Much of the humour arises from the mismatch between the language's apparent emotional intensity and its mechanical origin.

The machine combines romantic vocabulary according to a procedure.

Its output imitates conventions associated with private feeling.

Yet the reader knows that the words were assembled computationally.

The result exposes something about ordinary romantic language.

Love letters often rely upon familiar expressions.

People repeat metaphors, adjectives and declarations inherited from other writers.

If these conventions are sufficiently regular, a machine can imitate some of their patterns.

Strachey's experiment therefore works as a small satire of formulaic expression.

The machine does not have to understand love to reproduce recognisable forms of romantic language.

That is both the joke and the intellectual challenge.

3. What Exactly Did Strachey Author?

Suppose a human writer prepares twenty possible adjectives and twenty possible nouns.

The writer also provides several sentence structures.

The computer selects words from the collections and inserts them into the structures.

For example, consider this invented template:

My [ADJECTIVE] [NOUN] remembers your [ADJECTIVE] [NOUN].

The collections might contain:

Adjectives: distant, restless, silver, secret.

Nouns: heart, shadow, dream, voice.

The machine could produce:

My restless heart remembers your silver voice.

Or:

My secret shadow remembers your distant dream.

These examples are original teaching material. They are not quotations from Strachey's historical program.

They demonstrate the broad combinatorial principle rather than reconstructing his implementation.

The division of labour

We can identify several separate activities.

The human programmer selects the vocabulary.

The programmer defines the grammatical structures.

The programmer determines the selection procedure.

The computer performs selections according to that procedure.

The resulting text is displayed or printed.

The reader interprets it.

Which activity constitutes authorship?

There is no single answer that resolves every artistic, philosophical and legal question.

But we can make an important distinction.

The programmer is the author of the procedure.

The programmer may also be the author of the individual textual components.

The computer executes the procedure.

The individual output is produced through their combination.

If the process uses chance, the programmer may not know in advance which particular text will appear.

That does not make the program independent of human design.

The possible outputs are constrained by the supplied vocabulary and rules.

A space of potential letters

Suppose a simplified generator contains four choices in each of four positions.

The number of possible arrangements is:

N = 4⁴ = 256

A programmer can define all 256 possibilities through a comparatively small set of instructions and data.

The program does not need 256 complete letters written into its source.

It needs the components and a way to combine them.

This is the same principle encountered in Raymond Queneau's combinatorial sonnets.

But the role of the machine has changed.

In Queneau's original book, the reader physically manipulates the paper strips.

In Strachey's program, the electronic computer performs the selections.

The literary structure has become executable.

4. The Difference Between Writing a Sentence and Writing a Generator

Consider two approaches to producing a poem.

The first writer composes four lines:

The evening gathers at the gate. The empty windows hold the rain. A distant signal marks the hour. The silent town remembers pain.

The writer selects every word.

The order is fixed.

The poem may be revised, but the published version presents a particular arrangement.

Now imagine a second writer.

Instead of composing one complete poem, the writer supplies several alternatives for each line.

The writer also defines rules governing which alternatives may be selected.

A computer can then produce different poems by following those rules.

The author has moved from composing one output to designing a system.

Two creative problems

The first approach asks:

Which words should appear here?

The second asks:

What rules and collections of words could produce interesting results here?

These are different artistic problems.

The first requires attention to a particular sequence.

The second requires attention to a space of possible sequences.

A line that works beautifully in one poem may fail when combined with another line.

A generative writer must therefore consider compatibility.

The components should be able to participate in several potential contexts.

This is why generative writing can require considerable preparation.

The machine may perform the final assembly, but the author must design a system in which assembly is worthwhile.

The author as architect

A useful analogy is architecture.

An architect does not personally place every brick in a building.

The architect designs structures, relationships and constraints that guide construction.

Similarly, the author of a text generator may not select every word appearing in every output.

Instead, they design a procedure that establishes which outputs are possible.

The analogy has limits.

A building must satisfy physical requirements.

A poem is evaluated through artistic and interpretive criteria.

Nevertheless, both involve creating a system whose realised form depends upon a design.

Generative writing introduces a new form of literary responsibility.

The author must consider not only whether one particular output is successful, but whether the procedure produces an interesting range of outputs.

5. Theo Lutz and the Stochastic Sentence

In 1959, Theo Lutz produced another landmark experiment in computational writing.

Lutz was studying at the Technische Hochschule Stuttgart, now the University of Stuttgart.

He used a Zuse Z22 computer to generate texts from selected vocabulary.

His work appeared under the title Stochastische Texte, or Stochastic Texts, in the journal augenblick in 1959.

The publication was associated with the intellectual environment of philosopher and aesthetic theorist Max Bense.

The original article appeared in volume 4, issue 1, pages 3–9. The University's historical account and the surviving journal provide independent confirmation of the date.

Lutz selected words from Franz Kafka's novel The Castle and arranged them into mechanically generated sentences.

According to the ZKM Center for Art and Media's collection record, his source material included sixteen nouns, sixteen adjectives, four conjunctions and four pronouns. The system could produce more than four million sentence combinations.

This was not a modern language model trained on an enormous corpus.

The vocabulary was small and explicitly selected.

The grammatical structures were restricted.

The computer generated text by applying programmed rules and selections.

Why Kafka?

Kafka's writing often depicts bureaucratic uncertainty, inaccessible authority and individuals struggling to understand systems that govern their lives.

In The Castle, a protagonist named K. attempts to navigate an elusive administrative world.

Lutz's decision to use vocabulary from the novel gave the generated sentences a particular literary atmosphere.

Words associated with Kafka's fictional world could appear in new combinations.

But the computer did not reconstruct Kafka's narrative.

It did not understand K.'s circumstances.

It did not maintain the causal structure of the novel.

It selected words from a prepared collection and combined them according to a procedure.

The resulting texts could suggest Kafka's atmosphere without reproducing his storytelling.

This is an important difference between vocabulary and narrative.

A set of words can evoke a literary world.

But it does not automatically contain that world's characters, events or meanings.

6. What Does Stochastic Mean?

The word stochastic comes from mathematics and probability.

It describes processes involving randomness or probabilistic behaviour.

A stochastic text generator uses some process of selection in which the outcome is not fixed by a simple predetermined sequence of choices.

For example, a program might select one adjective from a collection according to assigned probabilities.

It might choose a noun from another collection.

It might then assemble the selections into a sentence.

Randomness within rules

Suppose we have three adjectives:

quiet, distant, restless.

And three nouns:

river, window, machine.

The system might generate:

The restless machine waits.

Or:

The quiet river waits.

The particular combination varies.

But the grammar is fixed.

The sentence always begins with The.

It always contains one adjective.

It always contains one noun.

It always ends with waits.

The randomness affects which components are selected.

It does not eliminate the rules.

Probability is not meaning

Imagine that quiet has a 50% selection probability, while distant and restless each have 25%.

The generator will tend to produce more sentences containing quiet.

That is a statistical property of the system.

It does not mean that quietness is more poetically valuable.

The author has chosen a distribution.

The computer follows it.

The reader interprets the resulting language.

Probability can influence the frequency of particular images or themes.

But it does not automatically determine their significance.

Pseudorandomness

Most ordinary computer programs that appear to make random selections use pseudorandom-number generators.

These algorithms produce sequences that have statistical properties resembling randomness for particular purposes.

Given the same algorithm and initial seed, the sequence can ordinarily be reproduced.

This distinction is important for understanding computational literature.

A program may appear unpredictable to a reader while remaining deterministic under specified conditions.

The author may deliberately use a fixed seed to make results reproducible.

Alternatively, a program may use a changing seed or another source of variability.

Lutz's historical work involved computationally generated selections rather than human improvisation at every step.

The precise implementation belongs to the history of the original Z22 program, not to the simplified examples used here.

The fundamental idea is that selection can vary while grammatical construction remains constrained.

7. A Small Machine for Making Sentences

We can build a simplified generator to examine the difference between composing a sentence and designing a procedure that produces sentences.

Our fictional setting is an abandoned observatory.

We want the machine to generate short, atmospheric statements about its surroundings.

The generator will use three grammatical positions:

Subject + Verb + Object

For each position, we provide three alternatives.

All nine phrases are original teaching material, not quotations or reconstructions of Strachey's or Lutz's work.

We can now create:

The machine watches the silent city.

Or:

The observatory remembers the forgotten signal.

The components are selected independently.

Since each of three positions contains three alternatives, the number of possible selection patterns is:

N = 3³ = 27

Our small system permits 27 distinct sentences.

But an interesting distinction appears immediately.

Not all 27 sentences will be equally effective.

The visitor questions the forgotten signal suggests a mysterious investigation.

The observatory watches the distant stars sounds relatively natural.

The silent city is not available as a subject because the author placed it in the object collection.

The vocabulary and grammatical positions determine which expressions can appear.

A finite Python generator

Here is a complete program that generates three sentences using fixed indexed choices.

It does not use random selection.

That decision makes the results completely reproducible and allows us to trace every operation.

subjects = [
    "The observatory",
    "The machine",
    "The visitor"
]


verbs = [
    "remembers",
    "watches",
    "questions"
]


objects = [
    "the distant stars",
    "the silent city",
    "the forgotten signal"
]


selections = [
    (1, 1, 0),
    (0, 0, 2),
    (2, 2, 1)
]


for subject_id, verb_id, object_id in selections:
    sentence = (
        subjects[subject_id]
        + " "
        + verbs[verb_id]
        + " "
        + objects[object_id]
        + "."
    )
    print(sentence)


total = len(subjects) * len(verbs) * len(objects)
print("Possible sentences:", total)

Exact output

The machine watches the distant stars.
The observatory remembers the forgotten signal.
The visitor questions the silent city.
Possible sentences: 27

Tracing the selections

Python uses zero-based indexing.

The first element of a list has index 0.

The second has index 1.

The third has index 2.

Our three selection tuples therefore identify particular components.

The first tuple is:

(1, 1, 0)

The program selects subject 1, verb 1 and object 0.

It then joins the three phrases with spaces and adds a full stop.

There is no grammatical analysis happening during execution.

The programmer has already arranged the alternatives so that they can occupy compatible positions.

The machine performs selection and assembly.

What this experiment proves

The program demonstrates a genuine computational process.

A relatively small amount of source code can describe a larger collection of possible sentences.

It also demonstrates an important limitation.

The program does not understand the observatory.

It does not know what a forgotten signal is.

It cannot explain why one sentence sounds more poetic than another.

Its grammar is limited to the structure supplied by its programmer.

Nevertheless, the outputs can suggest a fictional world.

Readers may imagine an abandoned building, forgotten scientific experiments or a machine preserving memories long after its creators have disappeared.

The literary interpretation occurs in the encounter between generated text and reader.

That is the essential mechanism of many early text generators.

8. Chance Is a Choice Made by the Author

Our program uses fixed selections.

It always prints the same three sentences.

But Strachey's and Lutz's historical experiments explored the use of variable selection to produce different outputs.

We could modify our teaching generator so that each component is selected using a pseudorandom-number generator.

The number of possible sentences would remain 27.

What changes is the procedure for choosing among them.

Three selection strategies

Imagine operating the same generator in three different ways.

Sequential selection systematically visits combinations in a predetermined order.

Fixed selection uses an explicit list of choices, as in our Python example.

Pseudorandom selection chooses indices according to an algorithm designed to produce statistically variable sequences.

Each method can operate on the same vocabulary and grammatical rules.

But the reader's experience differs.

Sequential selection makes the structure easy to investigate.

Fixed selection allows the author to produce specific results.

Pseudorandom selection introduces variation that may surprise the reader.

The important point is that randomness is not equivalent to unrestricted freedom.

The machine cannot select a word that does not exist in its vocabulary unless additional rules allow it to construct new words.

It cannot spontaneously introduce a fourth grammatical position unless the program supports that possibility.

It cannot transform the sentence generator into a complete detective novel merely by making more random selections.

Chance operates within the designed system.

The role of probability

We might assign unequal probabilities to the alternatives.

For example:

If selections follow these probabilities, the observatory will tend to appear more frequently over many outputs.

That could give the generated writing a particular atmosphere.

A generator that repeatedly mentions the observatory might suggest that the building is the central subject.

A generator favouring the visitor might feel more personal.

The author can therefore influence style through probability distributions.

This is a significant creative possibility.

The programmer does not need to choose every sentence.

Instead, the programmer can shape the statistical tendencies of the writing.

Randomness and surprise

A generated sentence may surprise its programmer.

Perhaps two independently chosen words create an unexpected metaphor.

Perhaps a combination suggests a narrative connection that nobody deliberately planned.

The surprise can be artistically valuable.

But it does not prove that the machine understands the metaphor or possesses creative intentions.

The combination may be unexpected because the programmer did not examine every possible result.

The machine has explored a possibility within the system's rules.

The reader interprets it.

This is one reason generative writing can be compelling even when its mechanism is simple.

The system can reveal combinations that its designer had not consciously considered.

9. From Mechanical Assembly to Literary Interpretation

What distinguishes a generated sentence from a meaningful literary event?

Consider this output:

The observatory remembers the forgotten signal.

Grammatically, the sentence is straightforward.

But observatories do not ordinarily remember in the human sense.

The verb gives the building a quality associated with living minds.

A reader might interpret this as personification.

Perhaps the observatory contains an old computer storing recordings.

Perhaps the building represents a forgotten civilisation.

Perhaps the line suggests that scientific instruments preserve traces of events their operators no longer remember.

The sentence acquires significance through interpretation.

The program does not need to contain any of these explanations.

It simply selects phrases.

Meaning can emerge from combination

Literature frequently creates meaning by placing familiar elements in unfamiliar relationships.

A single word may have several associations.

When combined with another word, those associations change.

Machine suggests technology.

Remembers suggests consciousness or stored information.

The forgotten signal suggests communication, absence and loss.

Together, the phrases invite a larger interpretation.

A generative system can produce such relationships without explicitly representing their literary implications.

But there is no guarantee that every combination will be equally interesting.

Some will be repetitive.

Some may be awkward.

Some may accidentally suggest something powerful.

The generator's vocabulary and structures influence the likelihood of these outcomes.

The reader's knowledge and expectations shape their interpretation.

The difference between grammar and understanding

Our program guarantees a simple grammatical pattern:

Subject + Verb + Object.

But grammar alone is not sufficient for coherent narrative.

A story requires more than individual sentences.

Characters must possess relevant histories.

Events must have consequences.

Objects introduced earlier may need to reappear later.

A fictional world normally maintains some continuity.

A sentence generator with independent selections does not automatically preserve those relationships.

For example, it might produce:

The visitor watches the distant stars.

Then:

The visitor remembers the forgotten signal.

A reader may connect the statements into a narrative.

But the generator itself does not necessarily remember that the visitor appeared in the earlier sentence.

It may simply have selected the same subject twice.

That distinction becomes increasingly important as computational writing develops.

Moving from sentence generation to narrative generation requires mechanisms for representing context, events, relationships and state.

Early experiments such as those of Strachey and Lutz helped demonstrate the possibilities of automated language construction.

They did not solve the entire problem of computational storytelling.

10. The Hidden Human Editor

There is another important complication in the history of early computer poetry.

The text produced directly by a machine may not be identical to the text eventually published.

A human researcher may select interesting outputs.

They may correct punctuation.

They may remove unsuccessful lines.

They may arrange generated passages into a preferred order.

These activities introduce another layer of authorship.

Research into the surviving material associated with Theo Lutz documents that the published Stochastic Texts involved authorial revision after generation.

This matters when describing the work historically.

It would be misleading to imagine that every aspect of the final published presentation necessarily emerged untouched from the computer.

The exact contributions of program execution and subsequent human intervention belong to the documented production history.

Generation and selection

Suppose a computer produces one thousand sentences.

A human editor selects ten.

Those ten are arranged into a poem.

Who authored the result?

The programmer designed the generator.

The computer produced the candidate sentences.

The editor selected and arranged the final text.

Perhaps one person performed both human roles.

Perhaps several people collaborated.

The final literary object reflects all those contributions.

This resembles other artistic processes.

A photographer may take hundreds of photographs and select a few for exhibition.

A filmmaker may record many hours of footage and assemble a ninety-minute film.

A poet may write dozens of drafts before publishing one.

Selection is not necessarily a trivial activity.

It can be central to the artistic result.

The generator as a source of material

One way to understand early computational writing is to treat the program as a mechanism for producing candidate material.

The generated sentences become resources for further composition.

A human writer can preserve, reject, modify or rearrange them.

Another approach treats the generator itself as the primary artistic work.

The outputs are instances of its behaviour.

Both approaches are legitimate, but they answer different questions.

In the first, the emphasis falls on the finished text.

In the second, the emphasis falls on the procedure.

The distinction will become particularly important as we encounter works that change continuously and cannot be reduced to one definitive printed version.

11. Can an Algorithm Be Creative?

We can now confront the question that has accompanied computational writing since its earliest experiments.

Can a computer be creative?

The answer depends partly upon what we mean by creativity.

Suppose we define creativity as producing something novel, surprising and valuable.

A generative program can certainly produce combinations that its programmer has not previously examined.

Some results may surprise readers.

Some may be judged aesthetically valuable.

But does that mean the program itself is creative?

There are several possible positions.

Creativity as an outcome

One approach evaluates the product.

If a text is original and artistically worthwhile, perhaps its production method should not determine its value.

A poem does not automatically become less moving because it was generated through computation.

Under this approach, computational systems can participate in creative production without necessarily possessing conscious intentions.

Creativity as intention

Another approach emphasises the creator's understanding and purpose.

A human poet may deliberately choose an image to express grief, humour or political criticism.

A simple combinatorial generator does not possess a comparable understanding of its outputs.

It follows programmed rules.

On this view, the creativity belongs primarily to the human designer and perhaps to the reader or editor who selects meaningful results.

Creativity as a process

A third approach examines the entire creative system.

The programmer designs constraints.

The software generates possibilities.

A human selects, modifies or interprets them.

Creativity may be distributed across several activities rather than located in one isolated moment.

These positions are not equivalent, and none resolves every philosophical dispute.

The historical examples help us avoid confusing different claims.

Strachey's machine produced romantic text.

That is a documented technical and literary achievement.

It does not establish that the computer experienced romance.

Lutz's program produced stochastic sentences from selected literary vocabulary.

That demonstrates automated language generation.

It does not establish independent literary judgement.

The systems could nevertheless produce interesting artistic material.

A machine does not need to possess the intentions of a poet to participate in the production of poetry.

Whether it should itself be called a poet remains a separate question.

12. The Author Who Writes Possibilities

Let us return to the imaginary observatory.

Our small Python program contains nine phrases arranged into three collections.

It can produce 27 different sentences.

The programmer has written a procedure rather than 27 complete sentences.

Now imagine expanding the system.

We introduce a collection of locations.

We add a time of day.

We allow the machine to remember what happened earlier.

We create characters whose actions change the state of the fictional world.

We define rules governing what may happen next.

The generator begins to resemble a narrative system.

Its output may contain sequences of related events rather than isolated sentences.

The author must now design not only vocabulary and grammar, but also continuity and causation.

The machine needs some representation of what has already occurred.

If a character has opened a door, later events should recognise that the door is open.

If an important object has been destroyed, it should not reappear without explanation.

If one character has learned a secret, subsequent dialogue may need to reflect that knowledge.

The problems begin to resemble those encountered in Chapter Six, where we modelled Mara's fictional world using state and rules.

But the emphasis has changed.

In that chapter, code represented actions in a story.

Here, computation produces the language through which a story might be told.

A new relationship between author and text

Traditional authorship often centres on a completed artefact.

A novel is written, revised and published.

Readers encounter the same sequence of words, although their interpretations differ.

Generative writing challenges that arrangement.

The author may create a system whose outputs vary between readings.

There may be no single definitive text.

The work may consist partly of the rules through which different texts can emerge.

The author's creative labour shifts towards designing a space of possibilities.

This does not make composition obsolete.

The author still selects language, defines structures and decides what kinds of results the system should permit.

But composition is no longer restricted to choosing one final sequence.

It may involve creating a procedure capable of producing many sequences.

The historical significance

Strachey's 1952 love-letter program and Lutz's 1959 stochastic texts were produced on early electronic computers under severe technological constraints.

Their vocabularies and grammatical procedures were limited.

Their outputs could be awkward, amusing or suggestive.

Yet they demonstrated a principle with enormous future consequences.

A computer could be used not only to store and transmit literature, but to generate literary language.

The machine had become an active participant in textual production.

It could select.

It could assemble.

It could repeat a procedure far more rapidly than a human operator manipulating paper strips.

And it could produce combinations that had not previously existed as complete written sentences.

The author had become, at least partly, a designer of algorithms.

The literary work could now be understood not only as a finished text, but also as a process through which texts are made.

13. The First Step Towards an Executable Literature

We began with a computer composing exaggerated love letters.

We then encountered another machine assembling sentences from Kafka's vocabulary.

Neither program required the computer to possess a human understanding of literature.

Both relied upon rules and prepared linguistic material.

Their significance lies in the new division of labour they introduced.

The human writer could design the system.

The machine could perform selections and combinations.

The reader could interpret the result.

This arrangement resembles the relationship between composer, instrument and listener, although the analogy has limits.

A musical instrument ordinarily responds to a performer's immediate actions.

A generative program may produce extended sequences without continuous human selection.

The programmer determines the possibilities in advance.

The executing system realises particular outcomes.

The next problem

What happens when the reader is allowed to influence the procedure?

Suppose the observatory program presents a choice.

Enter the observatory.

Follow the visitor.

Investigate the forgotten signal.

Each decision leads to different text.

The system remembers earlier choices.

Later passages change accordingly.

The reader is no longer merely receiving generated sentences.

They are navigating a structure.

The literary work becomes interactive.

And once a story can be entered through different paths, the familiar idea of a fixed beginning, middle and end becomes less secure.

Generative writing has shown us how an author can design a system that produces multiple textual outputs.

Interactive fiction introduces another transformation.

The reader's decisions can become part of the process that determines which text appears.

The author writes possibilities. The machine presents them. The reader chooses a path.

That is the next stage in the history of the executable book.

Questions to Take Away

1. What distinguishes Christopher Strachey's love-letter program from an ordinary document containing several prewritten letters?
2. Why is the distinction between Strachey's 1952 program and his 1954 published discussion historically important?
3. How did Theo Lutz use existing literary vocabulary without reproducing the narrative of Kafka's The Castle?
4. What is the difference between a stochastic process and a completely unconstrained process?
5. If a program uses a pseudorandom generator, can its outputs still be reproducible?
6. Why might a generated sentence possess literary significance even when the program does not understand its meaning?
7. If a human editor selects ten sentences from a thousand generated outputs, where should we locate the creative contribution?
8. Does a surprising output prove that the generating system possesses creative intentions?
9. What additional capabilities would a sentence generator need before it could produce a coherent extended story?
10. Is the literary work the generator, its individual outputs or the combined experience of running and interpreting it?

A Small Reader Experiment: Become the Algorithmic Author

The following experiment extends the observatory generator from Section 7.

It uses original text and a finite, predetermined procedure.

Step 1: Change the vocabulary

Replace the three subjects with:

subjects = [
    "The lighthouse",
    "The keeper",
    "The ocean"
]

Keep the original verbs and objects.

How does the atmosphere change?

The machine now produces sentences associated with a maritime setting rather than an abandoned observatory.

Step 2: Predict the output

Use these selections:

selections = [
    (0, 1, 0),
    (1, 0, 2),
    (2, 2, 1)
]

Remember that indexing begins at zero.

The verbs remain:

verbs = [
    "remembers",
    "watches",
    "questions"
]

The objects remain:

objects = [
    "the distant stars",
    "the silent city",
    "the forgotten signal"
]

Step 3: Examine the worked result

The selections produce:

The lighthouse watches the distant stars.
The keeper remembers the forgotten signal.
The ocean questions the silent city.
Possible sentences: 27

The number of possibilities is unchanged.

There are still three alternatives in each of three positions:

3 × 3 × 3 = 27

But the literary atmosphere is different.

The vocabulary suggests a lighthouse, a keeper and a mysterious relationship between the sea and a distant city.

The program's structure has not changed.

The author's vocabulary has.

This demonstrates how the same algorithm can support different literary worlds.

Step 4: Compare the outputs

Return to the original observatory vocabulary.

Compare:

The machine watches the distant stars.

with:

The lighthouse watches the distant stars.

The computational procedure is identical.

The difference lies in the selected noun.

Yet the reader may imagine very different scenes.

One suggests artificial intelligence or astronomical observation.

The other suggests navigation, isolation and the coast.

The machine performs the same operation.

The literary interpretation changes.

Step 5: Design a fourth grammatical position

Imagine adding a fourth collection containing endings such as:

before sunrise, without speaking, beneath the moon.

If each of the four positions contains three alternatives, the number of possible selection patterns becomes:

3^4=81

The number of possibilities has tripled.

But has the literary quality improved?

Not necessarily.

Some endings may work better with particular sentences.

Try selecting five combinations and judging their coherence.

Step 6: Reflect on authorship

Write a short paragraph answering this question:

Am I the author of the resulting sentences if I designed the vocabulary and selection rules but did not individually choose every output?

Consider the difference between creating the components, determining their possible arrangements, selecting a particular result and interpreting its significance.

What this experiment demonstrates: A generative program can be reused with different vocabularies and procedures. The algorithm determines how components are assembled, while human design and interpretation strongly influence the resulting literary experience.

Further Reading

Christopher Strachey: Original Documents and Archives

Christopher Strachey — Love-Letters Program (1952)

The original working papers are preserved in the Christopher Strachey archive. The collection catalogue identifies folders C.34 and C.35 as containing notes, calculations and routines for the Manchester love-letter program.

Centre for Scientific Archives — Christopher Strachey catalogue, PDF

Christopher Strachey — The "Thinking" Machine (1954)

Strachey's published discussion appeared in Encounter, October 1954, pages 25–31.

Electronic Literature Knowledge Base — Original publication record and facsimile access

Alan Turing's relationship with Strachey's early experiments

Andrew Hodges's historical Turing website describes Strachey's work at Manchester, his connection with Turing and the love-letter generator.

Alan Turing Scrapbook — The Turing Test and Love Letters

Theo Lutz: Primary Text and Institutional Archives

Theo Lutz — Stochastische Texte (1959)

The original publication appeared in augenblick, volume 4, issue 1, pages 3–9, in 1959. The journal contents record identifies the issue. A transcription of Lutz's original article is also available below.

augenblick — Journal contents record

Lutz — Original article transcription

Auer — Reconstruction and comparison with printout

University of Stuttgart — Theo Lutz and the Reconstruction of Stochastic Texts

The university documents the original Zuse Z22 program, its preservation in the German Literature Archive Marbach and later efforts to reconstruct its operation.

University of Stuttgart — Stochastic Texts and the Original Program

ZKM Center for Art and Media — Stochastische Texte

The museum's official collection record describes the 1959 work, its Zuse Z22 platform, its vocabulary and the surviving generated text.

ZKM — Stochastic Texts

Suggested Reading Order

Begin with the Strachey archival record to establish the historical date and nature of the love-letter program.

Then examine his 1954 article, paying attention to how early computer scientists discussed the relationship between machine behaviour and intelligence.

Next, read Lutz's original article in augenblick, alongside the ZKM and University of Stuttgart records.

Consider how the work combines programming, statistical selection, literary vocabulary and subsequent human editorial intervention.

The central historical development is the transition from manually constructed combinatorial literature to computer-executed procedures capable of producing text.

Up Next — The Story That Has No Single Path

Hypertext, Interactive Fiction and Branching Narratives

So far, our literary machines have generated sentences, poems and letters.

But most of their readers remain spectators.

The machine produces a text.

The reader receives it.

What happens when the reader can influence which text appears?

In the second half of the twentieth century, writers and computer scientists began exploring forms of electronic writing in which passages could be connected through selectable links.

A reader might follow one path through a story while another reader follows a different path.

An early decision might change which scenes become accessible.

A character's fate might depend on choices made many passages earlier.

The work would no longer consist of one fixed sequence of pages.

Instead, it would contain a network of possible readings.

Michael Joyce's afternoon, a story and Shelley Jackson's Patchwork Girl became important examples of literary hypertext.

Interactive fiction also developed through systems in which readers entered commands, explored simulated environments and influenced the state of fictional worlds.

These developments transformed the relationship between author, reader and text.

A writer could design a narrative space without specifying one compulsory route through it.

A reader could become an active participant in selecting or producing a particular experience.

But new problems emerged.

How can a story maintain coherence when readers choose different paths?

Can a narrative possess suspense if its events can be encountered in several orders?

Does reader choice produce genuine freedom, or merely movement among possibilities the author has already anticipated?

And if two people experience different sequences, have they read the same work?

Chapter Eleven will examine the history and structure of interactive literature, from linked passages to parser-based fictional worlds.

The next literary machine will no longer decide every sentence for the reader. It will begin asking the reader where the story should go.

Oxford — Strachey archive exhibition booklet