---
# System prepended metadata

title: 'Ch.5: 自動生成器（Auto-generator）'
tags: [Old Version]

---

---
tags: Old Version
---

:::info
Ch.5: Auto-generator (https://gitlab.com/aesthetic-programming/book/-/tree/master/source/5-AutoGenerator)
:::


# Ch.5: 自動生成器（Auto-generator）

![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_0.svg)

## setup() 設置（）

前一章討論了與輸入設備交互背後的數據捕獲，本章遵循輸入和輸出的概念來介紹抽像機器的概念。這是指通過自動操作的機器創建規則，廣泛稱為抽像機或圖靈機。數學家和計算機科學家艾倫·圖靈 (Alan Turing) 在他於 1936.1 發表的著名文章“關於可計算數，以及對 Entscheidungsproblem 的應用”中首次描述了這台機器。機器“可用於計算任何可計算的序列”2，即機器如何運行，並遵循處理輸入和產生輸出的預定指令序列。
While the previous chapter discussed the data capture underlying the interaction with input devices, this chapter follows the concepts of input and output to introduce the idea of the abstract machine. This refers to the creation of rules by a self-operating machine, widely known as an abstract machine or Turing machine. It was mathematician and computer scientist Alan Turing who first described this machine in his famous article “On Computable Numbers, with an Application to the Entscheidungsproblem,” published in 1936.1 He used the term “universal computing machine” to theorize a model that describes how a machine “can be used to compute any computable sequence,”2 i.e. how a machine operates, and follows a predetermined sequence of instructions that process input and produce output.
更具體地說，圖靈機能夠進行六種類型的基本操作（當時還沒有一種叫做計算機的東西），包括讀、寫、向左移動、向右移動、改變狀態和停止/停止。圖靈建議這些操作可以通過運行一個無盡的磁帶來執行（就像現代計算機中的內存一樣），其中包含有關讀取和寫入哪些符號以及如何移動的指令。這些指令構成了圖靈機的基本原理，3 也是現代計算，具有計算數字任務和自動化各種流程的能力。正如我們在上一章中部分介紹的那樣，這些來自基礎計算水平的指令似乎支持當代（信息）資本主義的更廣泛的生產、消費和分配過程。
More specifically, the Turing machine is capable of six types of fundamental operations (at the time there wasn’t a thing called a computer) including read, write, move left, move right, change state and halt/stop. Turing suggested these operations could be performed by running an endless tape (that worked like memory does in a modern computer) with instructions on what symbols to read and write, as well as how to move. These instructions constitute the fundamental principles of the Turing machine,3 but also modern computing, with the capability to compute numeric tasks and automate various processes. These instructions from a base level of computing seem to underwrite the wider processes of production, consumption and distribution of contemporary (informational) capitalism as we partly covered in the last chapter.
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_1.png)
圖 5.1：圖靈機的圖示4
Figure 5.1: An illustration of the Turing Machine4
本章將探討指令如何成為自適應系統的基本要素，重點是如何執行規則，以及它們如何產生意外和/或複雜的結果。
This chapter will explore how instructions are fundamental elements of adaptive systems, focusing on how rules are performed, and how they might produce unexpected and/or complex results.

關注規則和指令不僅是程式設計師要做的事情，也是您在遵循編織/編織模式 5 或配方時要做的事情（正如我們將在下一章的準備豆腐中看到的那樣）。藝術家也創作了以教學為基礎的藝術作品，例如 1960 年代和 1970 年代的激浪派和觀念藝術運動，旨在挑戰藝術的客觀性，並鼓勵其“非物質化”。6 有很多例子評論員將這些基於教學的作品與計算藝術聯繫起來。 7 例如，調查展覽“程式化：藝術中的規則、程式碼和編排，1965-2018”8 由克里斯蒂安·保羅在惠特尼美國藝術博物館組織(2018-19)，探討了基於教學的實踐如何響應技術並受技術影響。概念藝術家 Sol Le Witt 的作品是這裡最明顯的例子之一，它展示了即使基於一組指令，結果也可能因他人對指令的解釋而有所不同。例如，作品 Wall Drawing #289 由三個簡單的指令組成，但沒有指定線條的角度和長度：
Focusing on rules and instructions is not something only programmers do, but also something you do when following a knitting/weaving pattern5 or recipe (as we will see with the preparation of tofu in the next chapter). Artists have also produced instruction-based works of art, as is the case of the Fluxus and Conceptual Art movements of the 1960s and 1970s that set out to challenge art’s object-ness, and encourage its “dematerialization.”6 There are many examples of commentators making the connection between these instruction-based works and computational art.7 For instance, the survey exhibition “Programmed: Rules, Codes, and Choreographies in Art, 1965-2018,”8 organized by Christiane Paul at the Whitney Museum of American Art (2018-19), explored how instruction-based practices have both responded to, and been shaped by technologies. The work of conceptual artist Sol Le Witt is one of the obvious examples here and demonstrates how even when based on a set of instructions, the outcome might be different depending on how the instructions are interpreted by others. For example, the work Wall Drawing #289 consists of three simple instructions, but does not specify the angles and length of the lines:

1. 距中心二十四線。
 Twenty-four lines from the center.
2. 從每一邊的中點算起十二條線。
Twelve lines from the midpoint of each of the sides.
3. 每個角有十二條線。
Twelve lines from each corner.
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_2.png)
圖 5.2：此圖像是 Sol LeWitt 的作品 Wall drawing #289 (1976) 的軟體版本，並由 Chuck Grimmett9 進一步編碼
Figure 5.2: This image is the software version of the work Wall drawing #289 (1976) by Sol LeWitt, and is further coded by Chuck Grimmett9

“想法變成了製造藝術的機器，”正如 LeWitt 解釋的那樣。10 使用程式設計語言 Processing，11 這是 Casey Reas 的邀請，根據他們的指令渲染 LeWitt 的壁畫，從而探索12 在他的隨附文本中，Reas 做出了重要的區分，即 LeWitt 的程式將由人而不是機器來執行。然而，正是這種緊密的聯繫和重疊讓他感興趣，這也是 Processing 做為“軟體速寫本”發展的基礎，因為 Reas 希望程式設計像繪圖一樣直接和流暢。
“The idea becomes a machine that makes the art,” as LeWitt explains.10 Using the programming language Processing,11 this is taken as an invitation by Casey Reas to render LeWitt’s wall drawings on the basis of their instructions, thereby exploring the parallels of interpretation and process for each of them.12 In his accompanying text, Reas makes the important distinction that LeWitt’s programs are to be carried out by people rather than machines. Nevertheless it is the close connection and overlap that interests him, and underlies the development of Processing as a “software sketchbook” as Reas wanted programming to be as immediate and fluid as drawing.

這並非沒有先例。包括 Joan Truckenbrod 在內的藝術家已經探索了算法繪圖，例如在她的系列編碼算法繪圖中，可以追溯到 1970 年代和 80 年代。13 Entropic Tangle（見圖 5.3）在 1975 年使用 Fortran 程式設計語言使用大型計算機進行編碼帶打孔機和磁性存儲介質。該作品展示了許多大小和旋轉角度各不相同的多邊形，這些多邊形模擬了無形的自然力，並通過使用變數和數學調製結合了連續性和波動性。 Truckenbrod 對如何通過符號和數字重新解釋“自然”力感興趣，這些符號和數字進一步證明了系統中模糊性和自發性的本質。 14 遞歸分形幾何 15 和集群行為 16 是證明“熵”特性（缺乏秩序或可預測性）的例子) 基於計算的自組織和隨時間演變的自主代理 17。
This is not without precedence. Algorithmic drawing has been explored by artists including Joan Truckenbrod, for example in her series Coded Algorithmic Drawings that dates back to the 1970s and 80s.13 Entropic Tangle (see Figure 5.3) was coded in the Fortran programming language in 1975, using a mainframe computer with keypunch machine, and magnetic storage media. The work presents a number of polygons that vary in size, and angles of rotation that simulate invisible natural forces and incorporate continuity, and fluctuations by using variables and mathematical modulation. Truckenbrod is interested in how “natural” forces get re-interpreted by symbols and numbers that further demonstrate the nature of ambiguity and spontaneity in systems.14 Recursive fractal geometry15 and flocking behaviors16 are examples that demonstrate “entropic” qualities (lack of order or predictability) based on the self-organization of computation and autonomous agents17 that evolve over time.
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_8.jpg)
圖 5.3：Joan Truckenbrod，熵纏結（1975）。由藝術家提供
Figure 5.3: Joan Truckenbrod, Entropic Tangle (1975). Courtesy of the artist

這種方法很重要，不僅因為它提供了一種基於數學邏輯的機器繪製和創作作品的不同方式，而且還提供了一種機器創造力的感覺——就像前一章一樣——否定了意向性 18 並質疑了中心性人類（通常是男性主義）機構。在本章中，我們旨在探索人類與機器、非人類或動物（即螞蟻）的更複雜組合（或物種間關係 19）。
This kind of approach is important, not only because it offers a different way of drawing and authoring works by machines based on mathematical logic, but also to provide a sense of machine creativity that — as in the previous chapter — negates intentionality18 and questions the centrality of human (more often than not, masculinist) agency. In this chapter we aim to explore more complex combinations (or inter-species relations19) of humans and machines, nonhumans or animals (namely, ants).

如果我們在 x 和 y 坐標 100 和 120 處繪製一個白色橢圓，則指令的結果是可預測的。但這不一定是這種情況，因為某些類型的指令或指令組合可能會產生不規則的結果。如書中所述 10 PRINT CHR$(205.5+RND(1)); ：GOTO 10，10 Print 程式利用隨機性來生成對人類來說似乎是隨機的不可預測的過程和結果。這種“生成”能力質疑對創作過程的控製程度，正如以下對生成藝術的定義所揭示的：
If we were to draw an ellipse in white color at the x and y coordinate 100 and 120, the outcome of the instruction is predictable. But this needs not be the case as certain kinds of instructions or combinations of instructions can generate unruly results. As described in the book 10 PRINT CHR$(205.5+RND(1)); : GOTO 10, the 10 Print program utilizes randomness to generate unpredictable processes and outcomes that seem random to humans. This “generative” capacity questions the extent of control over the creative process, as the following definition of generative art reveals:

>“生成藝術是指任何 [原文如此] 藝術家使用系統的藝術實踐，例如一組自然語言、規則、計算機程式、機器或其他程式性發明，這些系統以某種程度的自主性啟動到或導致完成的藝術作品。”20
“Generative art refers to any art practice where [sic] artists use a system, such as a set of natural languages, rules, a computer program, a machine, or other procedural invention, which is set into motion with some degree of autonomy contributing to or resulting in a completed work of art.”20

值得注意的是，這個定義並不局限於計算機的使用，當我們繼續關注我們的示例程式碼時，記住這一點很重要。以下兩個示例 21 探討了解決一些自動生成問題的基於規則的程式，但與前面的示例一樣，我們對更廣泛的影響感興趣，包括隱藏的勞動力和其他有關自主的問題。
Significantly this definition does not limit itself to the use of computers and this is important to bear in mind as we proceed to focus on our sample code. The following two examples21 explore rule-based programs that address some of these issues of auto-generation, but as in previous examples we are interested in the wider implications that include hidden labor, and other issues concerning autonomy.

## start() 開始（）

第一個程式叫做 10 PRINT 指的是一行程式程式碼 *10 PRINT CHR$(205.5+RND(1));: GOTO 10*，用 BASIC 程式設計語言編寫，在 Commodore 64（當時流行的家用電腦）上執行1980 年代）。該程式在螢幕上生成一個無盡的圖案。這行程式碼印在 1982 Commodore 64 User's Guide 中，後來在網上發表，成為軟體研究領域展示創意計算歷史和文化的重要例子。 22 10 PRINT in p5.js 下面是用於幫助我們熟悉規則及其創造潛力，因為它展示了系統內一定程度的自主性。
The first program is called 10 PRINT referring to one line of program code 10 PRINT CHR$(205.5+RND(1));: GOTO 10, written in the BASIC programming language and executed on a Commodore 64 (a popular home computer during the 1980s). The program generates an endless pattern on the screen. The line of code was printed in the 1982 Commodore 64 User’s Guide and was later published online, and has become an important example in the field of software studies for demonstrating the history and culture of creative computing.22 10 PRINT in p5.js below is used to help familiarize us with the rules and its creative potential as it demonstrates some degree of autonomy within a system.

第二個程式名為 Langton's Ant (1986)。它是一種二維通用圖靈機，由計算機科學家 Christopher Langton 於 1986 年發明，他被認為是人工生命領域的創始人之一。 23 與 10 PRINT 的核心區別在於它生成複雜、緊急的方式行為只使用一組簡單的規則。
The second program is entitled Langton’s Ant (1986). It is a two-dimensional universal Turing machine invented in 1986 by the computer scientist Christopher Langton who is considered to be one of the founders of the artificial life field.23 The core difference with 10 PRINT is the way in which it generates complex, emergent behavior using only a simple set of rules.

## Exercise in class (10 PRINT) 課堂練習 (10 PRINT)
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_4.png)
圖 5.4：p5.js 中的 10 PRINT
Figure 5.4: 10 PRINT in p5.js

```javascript
/*10 print in Commodore64
Ref:
1. 10Print: 10 PRINT CHR$(205.5+RND(1)); : GOTO 10
2. Shiffman's video:
https://www.youtube.com/watch?v=bEyTZ5ZZxZs

Rules:
1. Throw a dice randomly
2. Half of the chance print a backward slash
3. The other half of the chance will print a forward slash
4. Fill the whole canvas with the randomly generated slash
invent your own 10Print by creating your own rules!
*/

let x = 0;
let y = 0;
let spacing = 10;

function setup() {
  createCanvas(windowWidth, windowHeight);
  background(0);
}

function draw() {
  stroke(255);
  if (random(1) < 0.5) {  //probabilty
    //backward slash
    //line(0,0,10,10); //example of backward slash
    line(x, y, x+spacing, y+spacing);
  } else {
    //forward slash
    //line(0,10,10,0); //example of forward slash
    line(x, y+spacing, x+spacing, y);
  }
  x+=10;
  if (x > width) {
    x = 0;
    y += spacing;
  }
}
```
RunMe https://aesthetic-programming.gitlab.io/book/p5_SampleCode/ch5_AutoGenerator/
1. 閱讀上面10 PRINT的源碼，然後復制，在自己的電腦上運行。 Read the source code of 10 PRINT above, then copy it, and run it on your own computer.
2. 討論以下10條PRINT規則並將它們映射到code24的相關行/塊：
Discuss the following 10 PRINT rules and map them to the related lines/blocks of code24:
- 擲骰子並打印反斜杠一半的時間
- Throw a dice and print a backslash half the time
- 在另一半時間打印正斜杠
- Print a forward slash the other half of the time
3. 繪製“隨機性”文字： Drawing on the text “Randomness”:
- 如何在 10 PRINT 中實施控制？
How is control being implemented in 10 PRINT?
- 規律性的（不可）可預測性是什麼？
What might the (un)predictability of regularity be?
- 什麼是計算機的隨機性？25
What is randomness to a computer?25
- 討論隨機性在 10 PRINT 中的使用和作用，以及更廣泛的藝術，包括文學和遊戲？
- Discuss the use and the role of randomness in 10 PRINT, and more generally in the arts, including literature, and games?
4. 嘗試修改現有規則，例如： Try to modify the existing rules, for example:
- 我們可以改變斜線的大小、顏色和間距嗎？
- Can we change the size, color, and spacing of the slashes?
- 除了反斜杠和正斜杠之外，我們還能有其他輸出嗎？
- Can we have outputs other than just the backward and forward slashes?
5. 10 PRINT 被許多藝術家、設計師和學生所採用。看看它提供的一些不同選項 10 PRINT 在 Twitter 上用標籤“#10print”記錄。你在課堂上的任務是用一套清晰的規則創建一個草圖，就像 10 PRINT 的修改版一樣。
10 PRINT has been appropriated by many artists, designers and students. Take a look at some of the different options it provides 10 PRINT that are documented on Twitter with the hastag “#10print.” Your task in class is to create a sketch with a clear set of rules that operates like a modified version of 10 PRINT.

## Langton’s Ant 蘭頓的螞蟻

雖然 10 Print 將指令和隨機性都做為生成過程來關注，但我們希望在自動化和生成程式的上下文中查看“湧現”的概念，在這些程式中，複雜的模式/結果由簡單的規則生成。 Langton's Ant 是一款經典的數學遊戲，模擬螞蟻的分子邏輯。細胞狀態的模擬受到經典圖靈機的啟發，該機可以通過讀取輸入給它的符號來執行計算任務，這些符號是根據一組規則繪製的。
While 10 Print focuses both on instructions and randomness as generative processes, we want to look at the concept of “emergence” in the context of automated and generative programs in which complex patterns/outcomes are generated by simple rules. Langton’s Ant is a classic mathematical game that simulates the molecular logic of an ant. The simulation of the cell’s state is inspired by the classic Turing machine that can be instructed to perform computational tasks by reading symbols fed to it on a strip of tape that were drawn up according to a set of rules.

下一節提供模擬細胞狀態的示例程式碼，以黑色或白色呈現為二維網格系統。根據簡單的規則（如下所述），螞蟻被認為是將細胞數據做為輸入處理的傳感器，然後細胞將改變其顏色，螞蟻將向四個可能的方向移動。漸漸地，螞蟻會將網格變成一個表現出緊急行為的更複雜的系統。
The next section provides the sample code that simulates the cell states, presented as a two-dimensional grid system in either black or white. Based on simple rules (as described below), an ant is considered to be the sensor that processes the cell’s data as input, then the cell will change its color and the ant will move in four possible directions. Gradually, the ant will turn the grid into a more complex system that exhibits emergent behavior.

![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_5_book2.png)
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_5.gif)
圖 5.5：Langton's Ant - 初始步驟
Figure 5.5: Langton’s Ant - initial steps

當螞蟻最初朝上時，圖 5.5 顯示了朗頓螞蟻的前 33 步，當它遵循以下兩個一般規則時：
With the ant initially facing up, Figure 5.5 shows the first thirty-three steps of Langton’s Ant when it follows the two general rules below:
1. 如果螞蟻在一個白色的單元格處，它會向右轉 90 度並變為黑色，然後做為一個單元向前移動一個單元格。
If the ant is at a white cell, it turns right 90 degrees and changes to black, then moves forward one cell as a unit.
2. 如果螞蟻在黑色單元格處，它會向左轉 90 度並變為白色，然後做為一個單元向前移動一個單元格。
If the ant is at a black cell, it turns left 90 degrees and changes to white, then moves forward one cell as a unit.

一開始，畫布只顯示網格系統，所有單個單元格都設置為白色。螞蟻有四個可能的移動方向——向上、向右、向下和向左——根據它所在單元格的顏色向左或向右旋轉 90 度。位於白色網格中心的螞蟻在開始時頭部向上。然後按照上述規則 1 將頭部方向從 UP 旋轉到 RIGHT，從而將白色單元格更改為黑色，並向前移動一個單位。第二步是再次遵循規則 1，因為新單元格仍然是白色的。螞蟻的頭部方向將向右轉 90 度，從 RIGHT 指向 DOWN，然後將白色單元格變為黑色，螞蟻向前移動一個單位。第三步和第四步與前面的類似，直到螞蟻遇到一個黑色的細胞。此時，螞蟻會按照規則 2 將單元格的顏色改回白色，然後向左轉 90 度而不是向右轉。複雜性增加。
In the beginning, the canvas only displays a grid system and all the individual cells are set to white. The ant has four possible directions it can move in — UP, RIGHT, DOWN, and LEFT — turning 90 degrees either left or right subject to the color of the cell it is on. The ant, located in the center of the white grid has its head pointing UP at the start. It then follows Rule 1 above to rotate the head direction from UP to RIGHT, thereby changing the white cell to black, and moving forward one unit. The second step is to follow Rule 1 again, because the new cell is still white. The ant’s head direction will turn right 90 degrees and point from RIGHT to DOWN, and then it changes the white cell to black and the ant moves forward one unit. The third and forth steps are similar to the previous ones, until the ant encounters a black cell. At this point, the ant will follow Rule 2 and change the cell’s color back to white, and then turn left 90 degrees instead of right. The complexity increases.

![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_6_book.png)
圖 5.6：Langton 的 Ant - 過程
![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_6.gif)
Figure 5.6: Langton’s Ant - process
圖 5.6 展示了螞蟻在最初的幾百次移動後如何開始構建新興的“高速公路”模式，並具有簡單的對稱模式。然後對稱性打破了，螞蟻似乎在中心隨機移動。經過幾千次迭代後，螞蟻開始構建高速公路模式，並無限重複，直到大多數細胞被重新配置，導致類似於圖 5.7 的結果，而螞蟻繼續移動並改變細胞的顏色。 26
Figure 5.6 shows how the ant starts building the emergent “highway” pattern after the first few hundred moves with simple symmetrical patterns. Then the symmetry breaks down and the ants seems to move randomly at the center. After several thousand iterations, the ant then starts building a highway pattern, and repeats indefinately until most of the cells are reconfigured, leading to something that is similar to Figure 5.7, while the ant continues to move and change the color of cells.26

![](https://gitlab.com/aesthetic-programming/book/-/raw/master/source/5-AutoGenerator/ch5_7.png)
圖 5.7：Langton’s Ant - 出現的快照
Figure 5.7: Langton’s Ant - snapshot of emergence

RunMe https://aesthetic-programming.gitlab.io/book/p5_SampleCode/ch5_AutoGenerator/sketch5_1/

## Source code (Langton’s Ant) 
```javascript=
/* Inpsired by Langton's Ant (1986) by Chris Langton and
Daniel Shiffman: https://tinyurl.com/ShiffmanLangton
other ref: learning: 2d array by Daniel Shiffman:
https://www.youtube.com/watch?v=OTNpiLUSiB4

Modified by Winnie Soon
Logic:
1. draw a grid with your desired size (grid_space) via initializing
a grid structure based on width and height, columns and width
2. set all the cell states as 0 (where 0 =off/white, 1 = on/black)
3. set initial (current) x, y position and direction in the setup()
4. logic starts - in the draw():
  - based on the current position to check if the cell
    hits the edges (width and height)
  - check the current state of the cell against the rules
  (2 rules in total and those also define the on/off state of the cell)
  - change color of the cell
  - update corresponding/latest ant's direction + state
  - move to next cell and loop again within #4
  - *'grid_space' needs to be dividable, as an integer, by the width and height of the canvas
*/

 //e.g 4, 5, 10 need to be dividable by the w and h of the canvas
let grid_space = 5;
let grid =[]; //on/off state
 //for drawing the grid purpose
let cols, rows;
//current position in terms of rows and columns, not actual pixels
let xPos, yPos;
//current direction of the ant
let dir;
const antUP = 0;
const antRIGHT = 1;
const antDOWN = 2;
const antLEFT = 3;
let offColor;
let onColor;

function setup() {
  createCanvas(1000, 700);
  offColor = color(255);  //offcolor setting
  onColor = color(0); //onColor setting
  background(offColor);
  grid = drawGrid();
  xPos = floor(cols/2);  //initial x position in integer
  yPos = floor(rows/2); //initial y position in integerS
  dir = antUP; //initial direction
  frameRate(20);
}
function draw() {
  /*just for running faster perframe,
  try changing the number e.g 1 instead of 100 */
  for (let n = 0; n < 100; n++) {
   checkEdges();
   let state = grid[xPos][yPos];
   //check the current cell's state
   //rule 1
   if (state == 0) {
    dir++;  // turn right 90°
    grid[xPos][yPos] = 1; //change the currect cell's state to 'on'
    fill(onColor);  //subsequent color change
    if (dir > antLEFT) {
      dir = antUP;  //reset the counter
    }
   //rule 2
   }else{
    dir--;  //turn left 90°
    grid[xPos][yPos] = 0; //change the current cell's state to 'off'
    fill(offColor);  //subsequent color change
    if (dir < antUP) {
      dir = antLEFT; //reset the counter
    }
   }
   rect(xPos*grid_space, yPos*grid_space, grid_space, grid_space);
   nextMove();
  }
}
function drawGrid() {
  cols = width/grid_space;
  rows = height/grid_space;
  let arr = new Array(cols);
  for (let i = 0; i < cols; i++) { //no of cols
    arr[i] = new Array(rows); //2D array
    for (let j = 0; j < rows; j++){ //no of rows
      let x = i * grid_space; //actual x coordinate
      let y = j * grid_space; //actual y coordinate
      stroke(0);
      strokeWeight(1);
      noFill();
      rect(x, y, grid_space, grid_space);
      arr[i][j] = 0;  // assign each cell with the off state + color
    }
  }
  return arr; //a function with a return value of cell's status
}
function nextMove () {
  //check which direction to go next and set the new current direction
  if (dir == antUP) {
    yPos--;
  } else if (dir == antRIGHT) {
    xPos++;
  } else if (dir == antDOWN) {
    yPos++;
  } else if (dir == antLEFT) {
    xPos--;
  }
}
function checkEdges() {
  //check width and height boundary
  if (xPos > cols-1) { //reach the right edge
    xPos = 0;    //go back to the left
  } else if (xPos < 0) {  //reach the left edge
    xPos = cols-1;  //go to the right edge
  }
  if (yPos > rows-1) { //reach the bottom edge
    yPos = 0; //go back to the top
  } else if (yPos < 0) { //reach the top edge
    yPos = rows-1;  //go to the bottom
  }
}
```
## Reading Langton’s Ant 讀蘭頓的螞蟻

有三個區域可以幫助您放大程式以減慢和調整大小。
There are three areas that can help you to zoom in on the program to slow down and adjust the size.
1. 讓 grid_space = 5;在第 2 行：如果將值更改為 10，則所有內容都會被放大。
let grid_space = 5; in Line 2: If you change the value to 10, everything will be enlarged.
2. 幀率（20）；在第 26 行：降低幀速率值以幫助減慢程式速度。
frameRate(20); in Line 26: Lower the frame rate value to help slow down the program.
3. 第 28 行中的 draw()：該函式包含一個 for 循環，其中 n 是螞蟻的步數。如果需要，您可以將 n < 100 減少到 n < 1（在第 31 行），即 for (let n = 0; n < 100; n++) { 這指示程式每幀僅處理 n 步。
draw() in Line 28: This function contains a for-loop where n is the ant’s number of steps. If so desired you can reduce the n < 100 to n < 1 (in Line 31), i.e for (let n = 0; n < 100; n++) { this instructs the program to only process n steps per frame.

下面不是逐行檢查程式碼，而是顯示每個函式的作用。
Instead of going through the code line by line, the following shows what each function does.

- 第17行的函式setup()：設置畫布大小，初始化螞蟻的頭部方向、幀率、顏色，準備繪製背景網格結構。
function setup() in Line 17: To setup the canvas size, initiate the ant’s head direction, frame rate, color, and to prepare drawing the background grid structure.
- 第 56 行中的函式 drawGrid()：將畫布分成網格。
function drawGrid() in Line 56: To divide the canvas into a grid.
- 函式 draw()：該主要函式檢查適用於 Langton's Ant 並更改單元格顏色的兩個規則。
function draw(): This main function checks the two rules that apply for Langton’s Ant and change the color of cells.
- 第74行的函式nextMove()：四個方向都是用數字格式構造的，這樣就可以通過變數dir++，通過程式設計實現螞蟻方向的增減（即dir++或dir--）來改變螞蟻的方向）。每個不同的方向（向上、向右、向下、向左）對應於沿畫布上的水平 (xPos) 或垂直 (yPos) 軸向前移動
function nextMove() in Line 74: The four directions are structured in a number format so that the variable dir++ can be used to change the ant’s direction by implementing the increment and decrement of the ant’s direction in programming terms (i.e dir++ or dir--). Each different direction (UP, RIGHT, DOWN, LEFT) corresponds to moving forward along either the horizontal (xPos) or the vertical (yPos) axis on the canvas.
- 第 86 行中的函式 checkEdges()：該函式檢查螞蟻是否移出框架。當它出現時，程式的編寫方式使其出現在相反的一側並繼續。
function checkEdges() in Line 86: This function checks whether the ant moves out of frame. When it does, the program is written in such a way that it appears on the opposite side and continues.

從技術上講，這裡沒有新的語法，因為前一章已經簡要介紹了二維陣列。但是，示例程式碼中對二維陣列和嵌套 for 循環有了新的使用。
Technically speaking, there is no new syntax here as the two-dimensional arrays have already been covered briefly in the previous chapter. However, there is a new use of two-dimensional arrays and nested for-loops in the sample code.

## Two-dimensional arrays & nested for-loops 二維陣列和嵌套 for 循環

Daniel Shiffman 創建了一個教程（書面 27 和視頻 28）來討論二維陣列如何本質上是其他陣列的陣列。 他還建議考慮使用網格結構的二維陣列是有用的，該網格結構與 Langton 的 Ant 的背景很好地對齊，後者被設計為具有列和行的二維網格。 由於我們需要識別每個單元格的狀態，我們需要知道每個單元格的確切 x 和 y 位置。
Daniel Shiffman has created a tutorial (written27 and video28) to discuss how a two-dimensional array is essentially an array of other arrays. He also suggests that it is useful to think of two-dimensional arrays using a grid structure which aligns nicely with the background of Langton’s Ant which is designed as a grid in two dimensions with both columns and rows. Since we need to identify the state of each cell, we need to know the exact x and y position of each cell.

讓我們再次檢查網格背景繪製的原始碼：
Let’s examine the source code again for the grid background drawing:

```javascript
function drawGrid() {
 cols = width/grid_space;
 rows = height/grid_space;
 let arr = new Array(cols);
 for (let i = 0; i < cols; i++) { //no of cols
  arr[i] = new Array(rows); //2D array
  for (let j = 0; j < rows; j++){ //no of rows
    let x = i * grid_space; //actual x coordinate
    let y = j * grid_space; //actual y coordinate
    stroke(0);
    strokeWeight(1);
    noFill();
    rect(x, y, grid_space, grid_space);
    arr[i][j] = 0;  // assign each cell with the off state + color
   }
 }
 return arr; //a function with a return value of cell's status
}
```
要創建陣列，我們使用語法 let arr = new Array(cols); （在第 4 行），此行表示以列為單位的網格，陣列的長度與列數相同。由於我們還需要指示行數，因此我們使用行 arr[i] = new Array(rows); 從列中的每個現有陣列中創建另一個陣列。 （見第 6 行）。此語法置於 for 循環下以循環遍歷每一列，然後添加行數（從畫布高度派生）。二維陣列的結構如下：arr[][]。
To create an array, we use the syntax let arr = new Array(cols); (in Line 4) and this line indicates the grid in columns and the length of the array is the same as the number of columns. Since we also need to indicate the number of rows, we create another array out of each existing array in the column using the line arr[i] = new Array(rows); (see Line 6). This syntax is put under a for-loop to loop through each of the columns, but then with the addition of number of rows (which is derived from the canvas height). Two-dimensional arrays are structured in this way: arr[][].

要知道網格內每個單元格的確切 x 和 y 坐標，我們使用公式 x = i * grid_space; y= j * grid_space;分別。通過使用兩個嵌套的 for 循環（參見第 5 行和第 7 行），程式循環遍歷每一列和每一行，直到程式到達最後一列。我們能夠使用語法 array[i][j] 獲得 x 和 y 坐標，該語法應用於列（使用變數 i）和行（使用變數 j）。
To know the exact x and y coordinates of each cell within a grid, we use the formula x = i * grid_space; and y= j * grid_space; respectively. By using two nested for-loops (see Lines 5 & 7), the program loops through each column and each row until the program reaches the last column. We are able to get the x and y coordinates with the syntax array[i][j], which is applied to columns (with the variable i) and rows (with the variable j).

因此，網格中的每個單元格都以二維陣列的結構表示。如上所示，您可以通過更改變數 grid_space 來放大或放大單元格大小，列數和行數取決於畫布寬度和高度，源自 cols = width/grid_space;和行 = 高度/網格空間；。每個單元格，以 array[i][j] 的形式，是一個單位，代表螞蟻可以在網格內移動的可能性（通過 i 和 j 的變化值）。
Therefore, each cell from the grid is represented in the structure of a two-dimensional array. As demonstrated above, you can zoom in or enlarge the cell size by changing the variable grid_space, and the number of columns and rows depends on the canvas width and height as derived from cols = width/grid_space; and rows = height/grid_space;. Each cell, in the form of array[i][j], is a unit represents a possibility that an ant can move within the grid (via the changing values of i and j).

自定義函式 drawGrid() 與我們在第 3 章“無限循環”中討論的略有不同。這個函式帶有返回值（在第 17 行）：return arr;。這意味著該函式將在完成後返回值 arr（以二維陣列的形式）。在這個Langton's Ant示例中，該函式用於繪製網格背景，並在螞蟻開始移動時標記每個單元格的初始狀態（關閉狀態）以備後用。
The customized function drawGrid() is slightly different from what we have discussed in Chapter 3, “Infinite loops.” This function comes with returned values (in Line 17): return arr;. This means that the function will return the values arr (in the form of two-dimensional arrays) when it has completed. In this Langton’s Ant example, this function is used to draw the grid background, and to mark the initial status (off state) of each cell unit for later use when the ant is started to move.

## Exercise in class 課堂練習

給自己一些時間來閱讀和修改程式碼，以及觀察 Langton's Ant 的不同階段。
Give yourself sometime to read and tinker with the code, as well as to observe the different stages of Langton’s Ant.

Langton 的 Ant 程式通過抽象表示螞蟻的世界，並對細胞顏色、運動和方向設置限制。 重新考慮已經實施的規則。 嘗試更改現有規則或添加新規則以使螞蟻表現不同？ （回想一下您在上一個練習中使用 10 PRINT 所做的更改。）
The Langton’s Ant program represents the world of an ant through abstraction, and sets limits on cell color, movement and direction. Rethink the rules that have been implemented. Try changing the existing rules or adding new rules so that the ant behaves differently? (Recall what you have changed in the previous exercise with 10 PRINT.)

在模擬生命系統時——比如昆蟲的複雜行為——似乎更注重過程而不是結果。 我們來討論以下問題：
In simulating living systems — such as the complex behavior of insects — there seems to be a focus on process over outcome. Let’s discuss the following questions:

你能想到並描述其他表現出緊急行為的系統和過程嗎？
Can you think of, and describe, other systems and processes that exhibit emergent behavior?

在這種情況下，您將如何理解自治？29 您在多大程度上認為機器是生成系統中的主動代理？ 對更廣泛的文化有何影響？
How would you understand autonomy in this context?29 To what extent do you consider the machine to be an active agent in generative systems? What are the implications for wider culture?

## While() 當（）

我們已經在前一章討論了釋放變化潛力的想法，似乎生成系統承諾類似的方式來設想現有系統是可變的或適應條件的。生命系統的相似之處在生命遊戲中得到了清晰的說明——由數學家喬恩康威於 197030 年開發——圖靈機的另一個例子以及進化過程如何由其初始狀態決定，不需要進一步的輸入，並產生湧現形式。 31 與蘭頓的螞蟻一樣，它同樣基於“細胞自動機”的原理，即一個規則的細胞網格，在這種情況下，每個細胞都處於有限數量的狀態之一，例如開或關，或活著或死了。這些是具有實際應用的強大比喻。
We already have discussed the idea of unleashing potential for changes in the previous chapter, and it would seem that generative systems promise something similar as a way to envisage existing systems as changeable or adaptive to conditions. The parallel to living systems is made clear in Game of Life — developed by the mathematician Jon Conway in 197030 — another example of a Turing machine and how an evolutionary process is determined by its initial state, requires no further input, and produces emergent forms.31 Like Langton’s Ant, it is similarly based on principles of “cellular automata,” i.e. a regular grid of cells, each in one of a finite number of states, such as on or off, or alive or dead, in this case. These are powerful metaphors with real-world applications.

每個單元格與其他直接相鄰的單元格相互作用，並發生以下轉換：
Each cell interacts with other, directly adjacent, cells, and the following transitions occur:

- 任何具有少於兩個活鄰居的活細胞都會死亡，就像人口不足一樣。
Any live cell with fewer than two live neighbors dies, as if by underpopulation.
- 任何有兩個或三個活鄰居的活細胞都會傳給下一代。
Any live cell with two or three live neighbors lives on to the next generation.
- 任何擁有三個以上活鄰居的活細胞都會死亡，就像人口過多一樣。
Any live cell with more than three live neighbors dies, as if by overpopulation.
- 任何只有三個活鄰居的死細胞都會變成活細胞，就像通過繁殖一樣。
Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

如果進化論的新達爾文主義邏輯——適者生存——還不夠令人擔憂，那么生命遊戲的“亡靈政治”維度32進一步令人不安：從人口和社區的角度闡述生與死，彷彿社會的一部分清潔計劃（或反烏托邦智慧城市33 項目）。這僅僅是一個糟糕的抽象的例子嗎？
If the evolutionary neo-Darwinian logic of this — where the fittest survive — were not worrying enough, Game of Life is further troubling for its “necropolitical” dimension32: articulating life and death in terms of populations and neighborhoods, as if part of a social cleansing program (or dystopian smart city33 project). Is this simply an example of poor abstraction?

也就是說，在這種情況下，適應性複雜有機體可以“自下而上”組裝自己，而無需中央“自上而下”的指揮和控制機制。 34 這顯示了當它變得不可能時的“革命”潛力預測變化將採取的方向，以及它是否會陷入更高層次的秩序或瓦解。回到螞蟻，對蟻群的研究表明在工作中沒有明顯的等級制度，儘管人類用挑釁性的術語命名螞蟻，但“女王”根本不是權威人物，而是一個產卵的工作人員，而螞蟻-工人合作而不是封建（順便說一句，工蟻都是雌性，但是螞蟻的性政治超出了我們的範圍，我們也意識到在蘭頓螞蟻示例中通過細胞顏色的變化推斷出的種族維度）。
That said, there is an alternative political potential here in the way an adaptive complex organism can assemble itself “bottom-up,” without a central “top-down” command and control mechanism.34 This demonstrates “revolutionary” potential when it becomes impossible to predict the direction change will take, and whether it will fall into a higher level of order or disintegrate into chaos. Returning to ants, the study of ant colonies reveal there is no discernible hierarchy at work, and although humans have named the ants in provocative terms, the “queen” is not an authority figure at all but an egg-laying functionary, and the ant-workers operate a cooperatively rather than feudally (incidentally, the worker ants are all female, however the sexual politics of ants are outside our scope, and we are also aware of the inferred racial dimension with the shift of cell color in the Langton’s Ant example).

更準確地說，根據複雜性理論，所有系統都包含不斷波動的子系統。 由反饋引起的一個或多個波動可能會改變先前存在的組織，因此無法控制系統的多個相互作用元素，也無法預測集體行為。 正如 Ilya Prigogine 和 Isabelle Stengers 在《Order Out of Chaos》中解釋的那樣：
To be more precise, and according to complexity theory, all systems contain subsystems that continually fluctuate. One or more fluctuations, resulting from feedback, could change the preexisting organization, and as such the multiple interacting elements of a system cannot be governed, and the collective behavior cannot be predicted. As Ilya Prigogine and Isabelle Stengers explain in Order Out of Chaos:

>“一個完全按照功能模型定義的社會將符合亞里士多德關於自然等級和秩序的思想。 每個官員都將履行他[原文如此] 被任命的職責。 這些職責將在各個層面轉化為整個社會組織的不同方面。 國王給建築師發號施令，建築師給承包商發號施令，承包商給工人發號施令。 相反，白蟻和其他社會昆蟲似乎接近“統計”模型。 正如我們所看到的，當個體之間的互動在某些情況下產生某些類型的集體行為時，似乎沒有白蟻巢穴建造背後的策劃者，但這些互動都沒有涉及任何全局任務，都是純粹的局部任務。 ”35
“A society defined entirely in terms of a functional model would correspond to the Aristotelian idea of natural hierarchy and order. Each official would perform the duties for which he [sic] has been appointed. These duties would translate at each level the different aspects of the organization of the society as a whole. The king gives orders to the architect, the architect to the contractor, the contractor to the worker. On the contrary, termites and other social insects seem to approach the ‘statistical’ model. As we have seen, there seems to be no mastermind behind the construction of the termites’ nest, when interactions among individuals produce certain types of collective behavior in some circumstances, but none of these interactions refer to any global task, being all purely local.”35

為了幫助理解湧現行為，我們可以參考圖靈 1952 年的文章“形態發生的化學基礎”，它描述了自然模式從同質、統一的狀態中自然產生的方式。 36 “形態發生”的這種想法是政治性的。理論家和活動家 Franco “Bifo” Berardi 曾用它來描述社會和政治的變遷，或者新形式出現並形成時。自動化過程不僅用信息技術取代了生產的物理行為，而且自動化改變了認知活動本身。對 Berardi 而言，這“意味著將認知活動減少到算法程式，並將“自動化插入到一般智力的社會存在中。”37 其後果之一是自動化正在取代政治決策— “是或否 [……] 沒有細微差別，沒有歧義”- 對貝拉爾迪來說，這意味著民主的終結，以及旨在取代有意識的自願選擇和決策的邏輯程式自動鏈的建立。根據 Berardi 的說法，機器不僅捕獲了人類的思維能力，而且還捕獲了我們的感覺能力。 38 他指出的部分問題是我們一直在從機器而不是其他人那裡學習單詞，39 其結果是我們的愛、溫柔和同情心被削弱了。我們可能會在此列表中添加“關懷”，從而援引女權主義技術科學，例如 Maria Puig de la Bellacasa 的作品。對於 Bellacasa 來說，關懷很重要，因為它讓人們關注事物如何結合在一起，關注它們的關係，“將事物轉化為關懷事物是一種與它們相關的方式，不可避免地受到它們的影響，並改變它們影響的潛力其他人。”40
To help understand emergent behavior, we might turn to Turing’s article of 1952 “The Chemical Basis of Morphogenesis” for its description of the way in which natural patterns naturally arise from homogeneous, uniform states.36 This idea of “morphogenesis” is something that political theorist and activist Franco “Bifo” Berardi has utilized to describe social and political mutation, or when new form emerges and takes shape. Processes of automation have not only replaced physical acts of production with information technology, but automation has transformed cognitive activity itself. To Berardi, this “implies the reduction of cognitive activity to algorithmic procedures, and the insertion of “automatisms into the social existence of the general intellect.”37 One of the consequences of this is that automation is taking the place of political decision-making — “Yes or no […] no nuances, no ambiguity” — and to Berardi this implies the end of democracy, and the establishment of an automatic chain of logical procedures intended to replace conscious voluntary choices, and decision-making. Not only have machines captured the human capacity for thinking, according to Berardi, but also our capacity to feel.38 Part of the problem he identifies is that we have been learning words from machines, not from other humans,39 the consequence of which is that our capacity for love, tenderness, and compassion are lessened. We might add “care” to this list, thereby invoking feminist technoscience, such as Maria Puig de la Bellacasa’s work. For Bellacasa, care is important as it draws attention to how things are held together, to their relationalities, “transforming things into matters of care is a way of relating to them, of inevitably becoming affected by them, and of modifying their potential to affect others.”40

沿著這些路線，並藉鑑女權主義技術科學，海倫·普里查德 (Helen Pritchard) 和 Winnie Soon 的藝術作品 Recurrent Queer Imaginaries 是一個座右銘助手，它不斷地生成座右銘，做為重新思考、重新詮釋和夢想城市生活的一種形式。鑑於為種族、性別和階級不公正而鬥爭的豐富歷史，座右銘助理使用關於酷兒和交叉生活的宣言和雜誌做為機器學習和生成過程的源文本。 41 這種在行動中進行關懷的方法的另一個例子是詩計算學院的數字愛情語言教學大綱 42，其中講師 Melanie Hoff 探索如何將程式碼培養為一種“愛情語言”，它比企業監視和開發系統更溫和、更治愈、更親密。 43 該課程涵蓋程式設計和自然語言處理的基石，以及探索情書做為一種詩意形式的歷史。
Along these lines, and drawing upon feminist technoscience, Helen Pritchard and Winnie Soon’s artwork Recurrent Queer Imaginaries is a motto assistant that endlessly generates mottos as a form of rethinking, reinterpreting and dreaming urban life. In light of the rich history of struggles for racial, sexual and class injustice, the motto assistant uses manifestos and zines for queer and intersectional life as source text for machine learning and generative processes.41 A further example of this approach to care in action is the syllabus Digital Love Languages at the School for Poetic Computation42, where the instructor Melanie Hoff explores how code can be cultivated as a “love language” that is more gentle, healing, and intimate than corporate systems of surveillance and exploitation.43 The course covers the building blocks of programming and natural language processing as well as explores the history of the love letter as a poetic form.

對程式設計中更多關愛的討論將我們帶到了最後一個例子，即 1953 年出現在曼徹斯特大學計算機系佈告欄上的生成性“情書”。這些計算機生成的愛的宣言是由克里斯托弗編寫的程式產生的Strachey 使用最早的可程式設計計算機 MUC（曼徹斯特大學計算機，Ferranti Mark I）的內建隨機生成器功能。一些人將其視為數字藝術的第一個例子，44 而雅各布·加布里（Jacob Gaboury）則將其視為對異性戀愛的批判，尤其是因為像圖靈這樣的 Strachey 是酷兒。 45 此外，這些信件可以說不僅僅是對同性愛的渴望，但是人機之愛。
This discussion of more love and care in programming brings us to our last example, the generative “love-letters” that appeared on the Manchester University Computer Department’s noticeboard in 1953. These computer-generated declarations of love were produced by a program written by Christopher Strachey using the built-in random generator function of the M. U. C.(Manchester University Computer, the Ferranti Mark I), the earliest programmable computer. Regarded by some as the first example of digital art,44 and by Jacob Gaboury as a critique of hetero-normative love, not least because Strachey like Turing was queer.45 Moreover these letters are arguably more than a longing for same sex love, but human-machine love.

藝術家 David Link 對硬件和原始程式進行了功能複制，對功能方面進行了細緻的研究。46 主程式相對簡單，使用循環和隨機變數來遵循句子結構：“你是我的——形容詞 — 實質性”和“我的 — [形容詞] — 實質性 — [副詞] — 動詞 — 你的 — [形容詞] — 實質性。”有些詞是固定的，有些是可選的，如方括號所示。該程式從選項列表中進行選擇——形容詞、副詞和動詞——並配置循環以避免重複。該軟體可以生成超過 3180 億個變體。就效果而言，對話結構對於建立“我”（程式編寫者）和“你”（人類讀者）之間的交流很重要，因此您會感覺自己被解決了。由此產生的情書提供了一種令人驚訝的溫柔表達，這與我們認為的計算過程的標準功能結果相反。這遠非還原論的愛情觀，也許對那些製作節目的人來說，挑戰是產生奇怪的重組形式，在這種形式中，發送者或接收者都不是通過指定性別、物種或形式來預先確定的。我們以示例輸出結束本章：
Artist David Link built a functional replica of both the hardware and the original program, following meticulous research into the functional aspects.46 The main program is relatively simple, and uses loops and a random variable to follow the sentence structure: “You are my — Adjective — Substantive,” and “My — [Adjective] — Substantive — [Adverb] — Verb — Your — [Adjective] — Substantive.” Some words are fixed and some are optional, as indicated by the square brackets. The program selects from a list of options — adjectives, adverbs, and verbs — and loops are configured to avoid repetition. The software can generate over 318 billion variations. In terms of effect, the dialogue structure is important in setting up an exchange between “Me” (the program writer) and “You” (human reader), so you feel personally addressed. The resulting love letters provide a surprising tenderness of expression that runs contrary to what we consider the standard functional outcomes of computational procedures. This is far from a reductionist view of love, and perhaps the challenge for those making programs is to generate queer recombinant forms in which neither sender or receiver are predetermined by specifying gender, species, or forms. We end this chapter with a sample output:

>親愛的寶貝
>你是我美麗的狂喜。我的迷戀美麗地依附於你可愛的慾望。我的迷戀渴望你的願望。我的野心非常喜歡你的愛。你是我親愛的熱情。
>你的渴望
>M.U.C.

>DEAR DARLING
>YOU ARE MY BEAUTIFUL RAPTURE. MY INFATUATION BEAUTIFULLY CLINGS TO YOUR ADORABLE LUST. MY INFATUATION LUSTS FOR YOUR ?>WISH. MY AMBITION CURIOUSLY LIKES YOUR LOVE. YOU ARE MY DEAR EAGERNESS.
>YOURS WISTFULLY
>M. U. C.


## MiniX: A generative program 迷你練習：一個生成程式

**目標：
Objectives:**
- 從頭開始實施基於規則的生成程式。
To implement a rule-based, generative program from scratch.
- 加強循環和條件語句的計算使用。
To strengthen the computational use of loops and conditional statements.
- 從概念上和實踐上反思自動發電機的想法。
To conceptually and practically reflect upon the idea of auto-generator.

**更多靈感：
For additional inspiration:**
{Software} Structure #003 A by Casey Reas (2004), https://whitney.org/exhibitions/programmed?section=1&subsection=6#exhibition-artworks.
Saskia Freeke的每日藝術（2018 年） Daily Art by Saskia Freeke (2018), https://sasj.nl/portfolio/daily/.
Ruth John 和 Tim Holman（未註明日期）的生成藝術，https://generativeartistry.com/tutorials/。 Generative Artistry by Ruth John and Tim Holman (n.d.), https://generativeartistry.com/tutorials/.
衍生式設計 - 草圖（未註明日期），http://www.generative-gestaltung.de/2/，以及原始碼，https://github.com/generative-design/Code-Package-p5.js。 Generative Design - sketches (n.d.), http://www.generative-gestaltung.de/2/, and source code, https://github.com/generative-design/Code-Package-p5.js.
約瑟夫·菲奧拉 (Joseph Fiola) 的 GenArt (2016)，帶有原始碼，https://github.com/JosephFiola/GenArt。 GenArt by Joseph Fiola (2016), with source code, https://github.com/JosephFiola/GenArt.
約翰康威的生命遊戲（1970 年），https://web.archive.org/web/20181007111016/ & http://web.stanford.edu/~cdebs/GameOfLife/。 Game of Life by John Conway (1970), https://web.archive.org/web/20181007111016/ & http://web.stanford.edu/~cdebs/GameOfLife/.
生成塔羅牌由 Melanie Hoff (2019)，https://www.melaniehoff.com/generativetarot/，原始碼 https://github.com/melaniehoff/generative-tarot-p5js。 Generative Tarot by Melanie Hoff (2019), https://www.melaniehoff.com/generativetarot/, source code https://github.com/melaniehoff/generative-tarot-p5js.
Recode 項目（以 1976-78 年的項目為特色），http://recodeproject.com/，以及 Nick Montfort 的 Memory Slam（2014 年），http://nickm.com/memslam/。 The Recode Project (featuring projects from 1976-78), http://recodeproject.com/, and Memory Slam by Nick Montfort (2014), http://nickm.com/memslam/.
Solving Sol by Brad Bouse (n.d.)，一個在 JavaScript 中實現 Sol LeWitt 指令的開放項目 https://github.com/wholepixel/solving-sol。 Solving Sol by Brad Bouse (n.d.), an open project to implement Sol LeWitt’s instructions in JavaScript https://github.com/wholepixel/solving-sol.

**任務（RunMe）：
Tasks (RunMe):**
1 從一張白紙開始。想出至少兩個您想要在生成程式中實現的簡單規則。
Start with a blank sheet of paper. Think of at least two simple rules that you want to implement in a generative program.
2 根據您在步驟 1 中設置的規則，設計一個生成程式，該程式至少使用一個 for 循環/while 循環和一個條件語句，但沒有任何直接交互。就讓程式運行吧。如果有幫助，您還可以考慮使用 noise() 和 random() 語法。
Based on the rules that you set in Step 1, design a generative program that utilizes at least one for-loop/while-loop and one conditional statement, but without any direct interactivity. Just let the program run. You can also consider using noise() and random() syntax if that helps.

**要考慮的問題（自述文件）：
Questions to think about (ReadMe):**

- 你的生成程式有哪些規則？描述您的程式如何隨著時間的推移而執行？規則如何產生緊急行為？
What are the rules in your generative program? Describe how your program performs over time? How do the rules produce emergent behavior?
- 規則和流程在您的工作中扮演什麼角色？ What role do rules and processes have in your work?
- 根據指定的閱讀，這個 MiniX 如何幫助您理解“自動發電機”的概念（例如通過規則的控制水平、自主性、愛和關懷）？你對本章的主題有什麼進一步的想法嗎？ Draw upon the assigned reading, how does this MiniX help you to understand the idea of “auto-generator” (e.g. levels of control, autonomy, love and care via rules)? Do you have any further thoughts on the theme of this chapter?

## Required reading 必讀

- 尼克·蒙特福特等人。 “隨機性”，10 PRINT CHR$(205.5+RND(1))； ：轉到 10，https://10print.org/（馬薩諸塞州劍橋：麻省理工學院出版社，2012 年），119-146。 Nick Montfort et al. “Randomness,” 10 PRINT CHR$(205.5+RND(1)); : GOTO 10, https://10print.org/ (Cambridge, MA: MIT Press, 2012), 119-146. 
- Daniel Shiffman，“p5.js - Javascript 中的二維陣列”，Youtube，https://www.youtube.com/watch?v=OTNpiLUSiB4。
Daniel Shiffman, “p5.js - 2D Arrays in Javascript,” Youtube, https://www.youtube.com/watch?v=OTNpiLUSiB4. 
- 喬恩、麥科馬克等人。 “關於生成計算機藝術的十個問題。” 萊昂納多 47，沒有。 2, 2014: 135–141。
Jon, McCormack et al. “Ten Questions Concerning Generative Computer Art.” Leonardo 47, no. 2, 2014: 135–141.

## Further reading 進一步閱讀
Philip Galanter，“生成藝術理論”，Christiane Paul 編，數字藝術伴侶（牛津：Blackwell，2016 年），http://cmuems.com/2016/60212/resources/galanter_generative.pdf。 Philip Galanter, “Generative Art Theory,” in Christiane Paul, ed., A Companion to Digital Art (Oxford: Blackwell, 2016), http://cmuems.com/2016/60212/resources/galanter_generative.pdf. 
“如何用程式碼繪圖 | Casey Reas，”Youtube 視頻，6:07，由創作者發布，2012 年 6 月 25 日，https://www.youtube.com/watch?v=_8DMEHxOLQE。 “How to Draw with Code | Casey Reas,” Youtube video, 6:07, posted by Creators, June 25 (2012), https://www.youtube.com/watch?v=_8DMEHxOLQE. 
Daniel Shiffman，“p5.js 編碼挑戰 #14：分形樹 - 遞歸”，https://www.youtube.com/watch?v=0jjeOYMjmDU。 Daniel Shiffman, “p5.js Coding Challenge #14: Fractal Trees - Recursive,” https://www.youtube.com/watch?v=0jjeOYMjmDU. 
Daniel Shiffman，“p5.js 編碼挑戰 #76：遞歸”，https://www.youtube.com/watch?v=jPsZwrV9ld0。 Daniel Shiffman，“noise() 與 random() - Perlin Noise 和 p5.js 教程”，https://www.youtube.com/watch?v=YcdldZ1E9gU。  Daniel Shiffman, “p5.js Coding Challenge #76: Recursion,” https://www.youtube.com/watch?v=jPsZwrV9ld0. Daniel Shiffman, “noise() vs random() - Perlin Noise and p5.js Tutorial,” https://www.youtube.com/watch?v=YcdldZ1E9gU.

# Notes 筆記
1 Alan Mathison Turing，“On Computable Numbers, with an Application to the Entscheidungsproblem”，倫敦數學會會刊 2，第 1 期（1937 年）：230-265。 ↩
Alan Mathison Turing, “On Computable Numbers, with an Application to the Entscheidungsproblem,” Proceedings of the London Mathematical Society 2, no.1 (1937): 230-265. ↩
2 圖靈，“關於可計算數”，241。↩
Turing, “On Computable Numbers,” 241. ↩
3 圖靈機的可視化可以在這裡找到：https://turingmachine.io/。 ↩
A visualization of the Turing Machine can be found here: https://turingmachine.io/. ↩
4 這是在線找到的圖像的修改版本，請參閱 http://storyofmathematics.lukemastin.com/20th_turing.html。 ↩
This is a modified version of the image found online, see http://storyofmathematics.lukemastin.com/20th_turing.html. ↩
5 Juli Laczko 之前在第 1 章“入門”中提到的藝術品網絡機器展示了編織和編碼技術之間的關係。請參閱 https://digital-power.siggraph.org/piece/webmachine/。 ↩
The previously mentioned artwork webmachines by Juli Laczko in Chapter 1, “Getting started,” shows the relation between weaving and coding technologies. See https://digital-power.siggraph.org/piece/webmachine/. ↩
6 參考露西利帕德，編輯。六年：1966 年至 1972 年藝術對象的非物質化（倫敦：加州大學出版社，1997 年）。 ↩
Reference to Lucy Lippard, ed. Six Years: The Dematerialization of the Art Object from 1966 to 1972 (London: University of California Press, 1997). ↩
7 許多例子之一，也與展覽有關，是 Geoff Cox 的“發電機：軟體藝術的價值”，在 Judith Rugg 和 Michèle Sedgwick 編輯，當代藝術和表演策展問題（布里斯托爾：智力，2007）， 147-162，見 https://monoskop.org/images/5/53/Cox_Geoff_2007_Generator_The_Value_of_Software_Art.pdf。這包括對 Adrian Ward 的 Auto-Illustrator 的描述，做為“生成器”展覽（2002-3）的盒裝版本發布，隨附的“用戶手冊”包含技術細節和評論文章。在許多方面，這為您正在閱讀的出版物樹立了先例。有關樂譜、腳本和程式之間相似之處的美學維度的更多信息，請參見 Geoff Cox、Alex McLean 和 Adrian Ward，“生成程式碼的美學”，生成藝術 00，國際會議，米蘭理工大學（2001 年）， https://www.academia.edu/10519146/The_Aesthetics_of_Generative_Code。 ↩
One example of many, and also connected to an exhibition, is Geoff Cox’s “Generator: The Value of Software Art,” in Judith Rugg and Michèle Sedgwick, eds., Issues in Curating Contemporary Art and Performance (Bristol: Intellect, 2007), 147-162, available at https://monoskop.org/images/5/53/Cox_Geoff_2007_Generator_The_Value_of_Software_Art.pdf. This includes a description of Adrian Ward’s Auto-Illustrator, released as a boxed version for the “Generator” exhibition (2002-3) with an accompanying “User’s Manual” that contained both technical detail and critical essays. In many ways this sets a precedent for the publication you are reading. For more on the aesthetic dimension of the parallels between scores, scripts, and programs, see Geoff Cox, Alex McLean, and Adrian Ward, “The Aesthetics of Generative Code,” Generative Art 00, international conference, Politecnico di Milano (2001), https://www.academia.edu/10519146/The_Aesthetics_of_Generative_Code. ↩
8 展覽“程式化：藝術中的規則、程式碼和編排，1965-2018”在紐約惠特尼美國藝術博物館舉行（2018年9月28日至2019年4月14日），由Christiane Paul和Carol Mancusi-Ungaro組織，與克萊蒙絲懷特。請參閱 https://whitney.org/exhibitions/programmed。一個被廣泛引用的先前例子是 1970 年在紐約猶太博物館舉辦的展覽“軟體 - 信息技術：它對藝術的新意義”，由傑克伯納姆策劃。對於伯納姆來說，“軟體”展覽鼓勵人們理解藝術和信息系統的底層結構，通過將計算機技術實踐與概念藝術結合起來，軟體被視為信息交流的隱喻。 ↩
The exhibition “Programmed: Rules, Codes, and Choreographies in Art, 1965–2018” was held at the Whitney Museum of American Art, New York (28 Sep 2018 – 14 Apr 2019), and organized by Christiane Paul and Carol Mancusi-Ungaro, with Clémence White. See https://whitney.org/exhibitions/programmed. A well-cited, prior example would be the 1970 exhibition “Software — Information Technology: Its New Meaning for Art,” at the Jewish Museum in New York, curated by Jack Burnham. For Burnham, the exhibition “Software” encouraged an understanding of the underlying structures in art and information systems, and by drawing together practices in computer technology with conceptual art, software was to be seen as a metaphor for information exchange. ↩
9 這是一個使用 JavaScript 程式設計的版本，使用 D3 和 jquery 庫，請參閱 https://github.com/wholepixel/solving-sol/blob/master/289/cagrimmett/index.html。 ↩
This is a version programmed with JavaScript, using D3, and jquery libraries, see https://github.com/wholepixel/solving-sol/blob/master/289/cagrimmett/index.html. ↩
10 Sol LeWitt 在 Lippard 編輯中引用。六年：從 1966 年到 1972 年藝術對象的非物質化。↩
Sol LeWitt cited in Lippard, ed. Six Years: The Dematerialization of the Art Object from 1966 to 1972. ↩
11 Processing 是一種靈活的軟體速寫和程式設計語言，由 Casey Reas 和 Ben Fry 於 2001 年發起，供用戶學習如何在視覺藝術的背景下進行編碼。請參閱 https://processing.org/。 ↩
Processing is a flexible software sketchbook and programming language, initiated by Casey Reas and Ben Fry in 2001, for users to learn how to code within the context of the visual arts. See https://processing.org/. ↩
12 有關這項工作和相關文檔的說明，請參閱 Casey Reas，“{Software} Structures”，https://artport.whitney.org/commissions/softwarestructures/text.html。 ↩
For an explanation of this work, and the assoicated documentation, see Casey Reas, “{Software} Structures,” https://artport.whitney.org/commissions/softwarestructures/text.html. ↩
13 請參閱此處的編碼算法繪圖系列：https://joantruckenbrod.com/gallery/#(grid|filter)=.coded。 ↩
See the Coded Algorithmic Drawings series here: https://joantruckenbrod.com/gallery/#(grid|filter)=.coded. ↩
14 參見 Joan Truckenbrod 的採訪 Motion Through Series，https://vimeo.com/286993496。 ↩
See Joan Truckenbrod’s interview Motion Through Series, https://vimeo.com/286993496. ↩
15 分形幾何圖案常見於伊斯蘭和非洲藝術、設計和建築的傳統中，具有由可重複和無限過程產生的自相似特徵。歐洲和亞洲文化中的分形設計傾向於模仿自然，但 Ron Eglash 觀察到，非洲設計更受其自身社會結構的影響，在這種結構中，分形被視為共享文化的一部分。參見 Ron Eglash，非洲分形：現代計算和本土設計（新不倫瑞克、新澤西和倫敦：羅格斯大學出版社，1999 年）；還有 Laura U. Marks, Enfoldment and Infinity: An Islam Genealogy of New Media Art (Cambridge, MA: The MIT Press: 2010)。另請參閱 Martin Žilák 在 p5.js 中繪製分形樹時使用遞歸的編碼示例，https://editor.p5js.org/marynotari/sketches/BJVsL5ylz。 ↩
The patterns of fractal geometry are commonly seen in the tradition of Islamic and African art, design and architecture, with the self-similar characteristic that is generated by repeatable and infinite processes. Fractal designs in European and Asian culture tend to mimick nature, but Ron Eglash observes that the African designs are more influenced by their own social structure in which fractals are regarded as part of a shared culture. See Ron Eglash, African Fractals: Modern Computing and Indigenous Design (New Brunswick, New Jersey, and London: Rutgers University Press, 1999); also Laura U. Marks, Enfoldment and Infinity: An Islamic Genealogy of New Media Art (Cambridge, MA: The MIT Press: 2010). See also a coding example of the use of recursivity in sketching a fractal tree in p5.js by Martin Žilák, https://editor.p5js.org/marynotari/sketches/BJVsL5ylz. ↩
16 請參閱 Craig Reynold 的 p5.js 原始碼的植絨行為，https://p5js.org/examples/simulate-flocking.html。 ↩
See Craig Reynold’s flocking behavior with the p5.js source code, https://p5js.org/examples/simulate-flocking.html. ↩
17 基於代理的模型將數據的數學建模描述為遵循環境或系統內規則的個體自主代理，隨著時間的推移產生動作和交互的緊急結果。 ↩
Agent-based model describes the mathematical modeling of data as individual autonomous agent that follow rules within an environment or a system, resulting in emergent outcomes of actions and interactions over time. ↩
18 Inke Arns, “Read_me, run_me, execute_me: Code as Executable Text: Software Art and its Focus on Program Code as Performative Text,” trans。 Donald Kiraly，MediaArtNet (2004)，參見：http://www.mediaartnet.org/themes/generative-tools/read_me/1/。 ↩
Inke Arns, “Read_me, run_me, execute_me: Code as Executable Text: Software Art and its Focus on Program Code as Performative Text,” trans. Donald Kiraly, MediaArtNet (2004), see: http://www.mediaartnet.org/themes/generative-tools/read_me/1/. ↩
19 顯然，關於這一點可以說更多，但我們的例子參考了 Donna Haraway 的《當物種相遇時》（明尼阿波利斯：明尼蘇達大學出版社，2007 年）。 ↩

Clearly much more could be said about this, but we refer, our example, to Donna Haraway’s When Species Meet (Minneapolis: Uiversity of Minnesota Press, 2007). ↩
20 菲利普·加蘭特，“什麼是創成藝術？複雜性理論做為藝術理論的背景”，在 GA2003 - 第六屆生成藝術會議，米蘭（2003 年）。 ↩
Philip Galanter, “What is Generative Art? Complexity Theory as a Context for Art Theory,” in GA2003 - 6th Generative Art Conference, Milan (2003). ↩
21 本章中的兩個程式碼示例改編自 Daniel Shiffman 的 Coding Train 系列，增加了更多註釋來解釋邏輯，以及在 Langton 的 Ant 示例中調整網格大小等額外功能。 ↩
The two code examples in this chapter are adapted from Daniel Shiffman’s Coding Train series with the addition of more comments to explain the logic, as well as extra features such as adjusting the grid size in the Langton’s Ant example. ↩
22 Nick Montfort 等人，10 PRINT CHR $(205.5+ RND (1))；：GOTO 10（馬薩諸塞州劍橋：麻省理工學院出版社，2012 年）。 ↩
Nick Montfort, et al, 10 PRINT CHR $(205.5+ RND (1));: GOTO 10 (Cambridge, MA: MIT Press, 2012). ↩
23 Christopher G. Langton，“用元胞自動機研究人工生命”，Physica D：非線性現象 22，第 1-3 期（1986 年 10 月）：120-49，https://doi.org/10.1016/0167-2789(86) )90237-X。 Christopher G. Langton, “Studying Artificial Life with Cellular Automata,” Physica D: Nonlinear Phenomena 22, no.1–3 (October 1986): 120–49, https://doi.org/10.1016/0167-2789(86)90237-X. ↩
↩
24 存儲庫中引入了更多註釋行，請參閱：https://gitlab.com/siusoon/Aesthetic_Programming_Book/-/blob/master/public/p5_SampleCode/ch5_AutoGenerator/sketch.js。 ↩
More comment lines are introduced in the repository, see: https://gitlab.com/siusoon/Aesthetic_Programming_Book/-/blob/master/public/p5_SampleCode/ch5_AutoGenerator/sketch.js. ↩
25 參見 Mads Haahr，“隨機性和隨機數簡介”，https://www.random.org/randomness/；和 Montfortet al，“隨機性”，119-146。 ↩
See Mads Haahr, “Introduction to Randomness and Random Numbers,” https://www.random.org/randomness/; and Montfortet al, “Randomness,” 119-146. ↩
26 Andrés Moreira、Anahí Gajardo 和 Eric Goles，“Langton’s Ant 的動態行為和復雜性”，Complexity 6，第 4 期（2001 年 3 月）：46–52，https://doi.org/10.1002/cplx.1042。 ↩
Andrés Moreira, Anahí Gajardo and Eric Goles, “Dynamical Behavior and Complexity of Langton’s Ant,” Complexity 6, no.4 (March 2001): 46–52, https://doi.org/10.1002/cplx.1042. ↩
27 請參閱為處理社區編寫的“二維陣列”，https://processing.org/tutorials/2darray/。 ↩
See “Two-dimensional Arrays” written for the Processing Community, https://processing.org/tutorials/2darray/. ↩
28 請參閱 https://www.youtube.com/watch?v=OTNpiLUSiB4 中 p5.js 中的 2D 陣列視頻說明。 ↩
See the video instruction on 2D Arrays in p5.js at https://www.youtube.com/watch?v=OTNpiLUSiB4. ↩
29 例如，生成藝術家 Marius Watz 在 The Olhares de Outono (2007)，https://vimeo.com/26594644 中的演講“美麗的規則：創造力的生成模型”中會建議“自主是最終目標”。 ↩
For instance, generative artist Marius Watz would suggest that “autonomy is the ultimate goal”, from his talk “Beautiful Rules: Generative Models of Creativity,” in The Olhares de Outono (2007), https://vimeo.com/26594644. ↩
30 有關康威生命遊戲和相關元胞自動機的更多信息，請訪問 https://www.conwaylife.com/。 ↩
More information on Conway’s Game of Life and related cellular automata can be found at https://www.conwaylife.com/. ↩
31 有關 Conway 的 The Game of Life 的進一步討論和原始碼，請參見：https://web.archive.org/web/20181007111016/ & http://web.stanford.edu/~cdebs/GameOfLife/。 ↩
For further discussion and the source code for Conway’s The Game of Life, see: https://web.archive.org/web/20181007111016/ & http://web.stanford.edu/~cdebs/GameOfLife/. ↩
32 延續生命政治，這是米歇爾·福柯創造的一個術語，用來表示使用權力來控制人們的生活，亡靈政治是使用社會和政治權力來決定某些人如何生活而其他人必須如何死亡。參見 Achille Mbembe，“Necropolitics”，公共文化 15，第 1 期（2003 年）：11-40。 ↩
Continuing from biopolitics, a term coined by Michel Foucault to indicate the use of power to control people’s lives, necropolitics is the use of social and political power to dictate how some people may live and others must die. See Achille Mbembe, “Necropolitics,” Public Culture 15, no.1 (2003): 11–40. ↩
33 參見 Anders Visti 和 Tobias Stenberg 的藝術作品 WUOUS，該作品使用 Langton’s Ant 的實現來質疑所謂的智慧城市的程式邏輯：https://andersvisti.dk/work/wuos-2019。 ↩
See the artwork WUOUS by Anders Visti and Tobias Stenberg which uses an implementation of Langton’s Ant to question the procedural logic of so-called smart cities: https://andersvisti.dk/work/wuos-2019. ↩
34 有關緊急行為的更多信息，請參見 Steven Johnson, Emergence: The Connected Lives of Ants, Brains, Cities and Software (London: Penguin, 2001), 20。↩
For more on emergent behaviour, see Steven Johnson, Emergence: The Connected Lives of Ants, Brains, Cities and Software (London: Penguin, 2001), 20. ↩
35 Ilya Prigogine 和 Isabelle Stengers，《走出混沌：人類與自然的新對話》（倫敦：豐塔納，1985 年），205。↩
Ilya Prigogine and Isabelle Stengers, Order Out of Chaos: Man’s New Dialogue With Nature (London: Fontana, 1985), 205. ↩
36 Alan Mathison Turing，“形態發生的化學基礎”，倫敦皇家學會哲學彙刊 B，237，第 641 期（1952 年）：37-72，doi：10.1098/rstb.1952.0012。 JSTOR 92463。↩
Alan Mathison Turing, “The Chemical Basis of Morphogenesis,” Philosophical Transactions of the Royal Society of London B, 237, no.641 (1952): 37–72, doi:10.1098/rstb.1952.0012. JSTOR 92463. ↩
37 Franco “Bifo” Berardi，“The Neuroplastic Dilemma: Consciousness and Evolution”，e-flux 期刊第 60 期（2014 年 12 月），https://www.e-flux.com/journal/60/61034/the-neuroplastic-困境意識與進化/。 “通用智力”是取自馬克思《大綱》的一個關鍵概念，在“機器碎片”一文中，用於表示技術專長和社會智力的結合。 Terranova 也藉鑑了這一概念，她認為機器的進化也會釋放生產力，如第 4 章“數據捕獲”中所述。 ↩
Franco “Bifo” Berardi, “The Neuroplastic Dilemma: Consciousness and Evolution,” in e-flux journal #60 (December 2014), https://www.e-flux.com/journal/60/61034/the-neuroplastic-dilemma-consciousness-and-evolution/. “General Intellect” is a key concept taken from Marx’s Grundrisse, in the passage “Fragment on Machines,” and is used to indicate the coming together of technological expertise and social intellect. Terranova also draws on this concept when she argues that the evolution of machinery also unleashes productive powers, as referenced in Chapter 4, “Data Capture”. ↩
38 Franco “Bifo” Berardi, Precarious Rhapsody: Semiocapitalism and the Pathologies of the Post-Alpha Generation (London: Minor Compositions, 2009), 9. 有關決策政治的更多信息，請參閱 Luciana Parisi 的“重新程式設計決策主義”，e- Flux #85（2017 年 10 月），https://www.e-flux.com/journal/85/155472/reprogramming-decisionism/。 ↩
Franco “Bifo” Berardi, Precarious Rhapsody: Semiocapitalism and the Pathologies of the Post-Alpha Generation (London: Minor Compositions, 2009), 9. For more on the politics of decision-making, see Luciana Parisi’s “Reprogramming Decisionism,” e-flux #85 (October 2017), https://www.e-flux.com/journal/85/155472/reprogramming-decisionism/. ↩
39 在 N. Katherine Hayles 的《我的母親是一台計算機》中，她描繪了在 1930 年代和 1940 年代期間，主要是如何僱用女性進行計算，這些女性被稱為計算機。 N. Katherine Hayles，我的母親是一台計算機（芝加哥：芝加哥大學出版社，2005 年）。海爾斯的頭銜取自安妮·巴爾薩莫 (Anne Balsamo) 所著《性別身體技術》一書中的一章，她的母親就是其中一台計算機。 ↩
In N. Katherine Hayles’ My Mother Was a Computer, she charts how, during the 1930s and 1940s, mainly women were employed to do calculations who were referred to as computers. N. Katherine Hayles, My Mother Was a Computer (Chicago: University of Chicago Press, 2005). Hayles takes her title from a chapter in the book Technologies of the Gendered Body by Anne Balsamo, whose mother was one of these computers. ↩
40 Maria Puig de la Bellacasa，“技術科學中的關注事項：組裝被忽視的事物”，《科學社會研究》第 41 期，第 1 期（2010 年），99。↩
Maria Puig de la Bellacasa, “Matters of Care in Technoscience: Assembling Neglected Things,” in Social Studies of Science 41, no.1 (2010), 99. ↩
41 基於基於規則的語音技術，每個格言助手根據單詞中的字符序列自動書寫以形成句子。所有的單詞和句子都基於在倫敦國王十字車站新開發項目的中心發現的種子文本“Not for Self, but for All”，該區域的許多酷兒空間已被替換科技公司和初創企業。總而言之，Recurrent Queer Imaginaries“呼籲從公司新殖民主義的想像、操作不公正中回收酷兒空間，並以不同的方式重新想像它們，做為對酷兒解放的承諾。”在視頻文檔中查看 Recurrent Queer Imaginaries 生成的座右銘示例：https://digital-power.siggraph.org/piece/recurrent-queer-imaginaries/。 ↩
Based on rule-based diastic techniques, each motto assistant writes automatically according to a sequence of characters in a word to form sentences. All the words and sentences are based on the seed text “Not for Self, but for All” that was found in the heart of the new development of King’s Cross in London, an area in which many queer spaces have been closed down with the replacement of tech companies and start-ups. In summary, Recurrent Queer Imaginaries “is a call to reclaim queer spaces from corporate neocolonial imaginations, operational injustices and reimagine them differently for all, as a commitment to queer liberation.” See an example of a generated motto from Recurrent Queer Imaginaries, in video documentation: https://digital-power.siggraph.org/piece/recurrent-queer-imaginaries/. ↩
42 詩歌計算學院是紐約的一所藝術家經營的學校，成立於 2013 年，探索程式碼、設計、硬件和理論的交叉點——特別關注藝術干預，請參見：https://sfpc.io/。 ↩
The School for Poetic Computation, an artist-run school in New York that was founded in 2013, explores the intersections of code, design, hardware and theory — focusing especially on artistic intervention, see: https://sfpc.io/. ↩
43 參見數字愛情語言♡肯定程式碼，http://lovelanguages.melaniehoff.com/syllabus/。 ↩
See Digital Love Languages ♡ Codes of Affirmation, http://lovelanguages.melaniehoff.com/syllabus/. ↩
44 Noah Wardrip-Fruin，“Christopher Strachey：第一位數字藝術家？”，Grand Text Auto，加州大學聖克魯斯分校工程學院（2005 年 8 月 1 日）。 ↩
Noah Wardrip-Fruin, “Christopher Strachey: The First Digital Artist?,” Grand Text Auto, School of Engineering, University of California Santa Cruz (August 1, 2005). ↩
45 Jacob Gaboury，“計算的酷兒歷史”，Rhizome（2013 年 4 月 9 日）。我們在第 7 章“Vocable Code”中回到圖靈的性問題。 ↩
Jacob Gaboury, “A Queer History of Computing,” Rhizome (April 9, 2013). We return to the issue of Turing’s sexuality in Chapter 7, “Vocable Code”. ↩
46 David Link 的 LoveLetters_1.0：MUC=Resurrection 於 2009 年首次展出，並於 2012 年成為卡塞爾 dOCUMENTA(13) 的一部分。詳細說明和文檔可在 http://www.alpha60.de/art/love_letters 中找到/.另請參閱 Geoff Cox，David Link 的“介紹”，Das Herz der Maschine，dOCUMENTA (13): 100 Notes - 100 Thoughts, 100 Notizen - 100 Gedanken #037（柏林：Hatje Cantz，2012 年）。 ↩
David Link’s LoveLetters_1.0: MUC=Resurrection was first exhibited in 2009, and was part of dOCUMENTA(13), Kassel, in 2012. Detailed description and documentation can be found at http://www.alpha60.de/art/love_letters/. Also see Geoff Cox, “Introduction” to David Link, Das Herz der Maschine, dOCUMENTA (13): 100 Notes - 100 Thoughts, 100 Notizen - 100 Gedanken # 037 (Berlin: Hatje Cantz, 2012). ↩
47 Lucysuchman，人機重構：計劃和情景行動（劍橋：劍橋大學出版社，2007 年），217-220。 ↩
Lucy Suchman, Human-Machine Reconfigurations: Plans and Situated Actions (Cambridge: Cambridge University Press, 2007), 217-220. ↩
48 參見 Barend Köbben 在 2014 年實現的 Langton's Ant 的基於 Web 的逐步運行，https://kartoweb.itc.nl/kobben/D3tests/LangstonsAnt/。 ↩
See the web-based step by step running of the Langton’s Ant implemented by Barend Köbben in 2014, https://kartoweb.itc.nl/kobben/D3tests/LangstonsAnt/. ↩