Talk:Regularity
From Maze
Alternate Outline for debate
1. The Grid in Culture and Computation [important grid in the history of visual images and computation includes Jaquard, core memory ]
2. The Grid, Time, and Process in the Arts [flatten and fold together the two sections]
3. Doppelgangers [visually similar examples from the Arts, including Truchet]
4. From Circle to Square [history of the screen]
5. The Flow of Control
6. Branching and Loops
Outline for Repeating: Regularity in Time and Process
1. Motion + Generative are essential to 10 PRINT
- 10 PRINT is performed by C64
2. Repeating Motion in Modern Art
- Naum Gabo and Pevsner Manifesto
- Hans Richter and Viking Eggeling in abstract animation
- Repetition in Video Art (Richard Serra “Hand Catching Lead”, Bruce Nauman "Square Dance")
- Repetition in Experimental Animation (Lillian Schwartz "ENIGMA", Norman McClaren "Synchromy", Tony Conrad "Flicker")
- Repetition in American Minimalist Music (Reich "Piano Phase" and "Clapping Music", Glass, more...)
- Repetition in Performance Art (Acconci "Step Piece" Alan Kaprow "Work, A Happening September 1969" )
- Dance (Lucinda Childs, Philip Glass and Sol LeWitt) brings it all together
3. Generative Aesthetics
- Max Bense as influence on Nees, Nake, Mohr. Cybernetic Serendipity
- Modern definition of Generative (from Gelertner)
- The Generative has less precedent, early computer images were generative in space, but not time
- Game of Life as rules followed on a grid in generative way
[Original List]
- The origin of the kinetic w/in 20th Century art, Naum Gabo (quote from Manifesto, 1920)
- Music (Reich "Piano Phase" and "Clapping Music", Glass, more...)
- Video Art (Richard Serra “Hand Catching Lead”, Bruce Nauman "Square Dance")
- Dance (Lucinda Childs, Philip Glass and Sol LeWitt http://blogs.walkerart.org/visualarts/2011/02/17/sol-lewitts-expanding-grid/ )
- Performance Art (Acconci, Step Piece http://www.medienkunstnetz.de/works/step-piece/ http://www.rovetv.net/va-step-piece.html, Alan Kaprow "Work, A Happening September 1969" )
- Generative Aesthetics of Max Bense
- Game of Life is a process on a grid, fascination since invented, holds on
Outline possibilities for GRID
(Note: this 4-part GRID outline was developed through a quick conversation between Nick and myself. It's not meant to be comprehensive and the section names are certainly not right. Casey, 16 July 2011)
- Jacquard Loom and Knitting (exchange patterns through cards) . a textile is a grid from crossing warp and weft. the punched card grid follows from the textile grid: http://en.wikipedia.org/wiki/File:Kette_und_Schu%C3%9F.jpg . exchanging codes that produce patterns . see Fabric Workshop and Museum, show at craft museum in SF
- Medieval Patterns, religious order (http://en.wikipedia.org/wiki/Sebastien_Truchet) - (I added this section, but changed the title, because Truchet wasn't medieval. His work dates to 1704, meaning he predates the Jacquard Loom by a century, so I've also moved this section to the top of the chapter. - Mark, 20 July 2011)
- Screen grid (move from oscilliscope to grid, Radial coordinates to Cartesian, circle to rectangle TV) . progression from circle to square . started circle, then distorted into a rectangular shape (tv tube is on it's way to becoming square) . transition to LCD panel from CRT to LCD
- C64 the Grid of 40 x 25 characters
- Constructivism, Mondrian, Minimalism and Grid in visual art (related to 10 PRINT)
Notes for Grid (Casey) 16 July
- Birth of Cartesian space and objective rational view - Early computer core memory in a grid: http://en.wikipedia.org/wiki/File:Ferrite_core_memory.jpg - Paul Klee in Pedagogical Sketchbook into MoMA work - Rhythm!
Text Remaining from "Iteration"
Perhaps the single most important programming idea is that of a loop. - BASIC: A Manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System, 1 October 1964
Transistors and processors
If you zoom in far enough all a computer ever does is run one iterative loop after another, up to five hundred thousand times per second in the Commodore 64's MOS Technologies 6510 processor and billions of times per second in a modern chip. The iterations are not just restricted to processors though: almost every component in the computer, including memory, input/output controllers, and video adapters are all constantly iterating, no matter what code the programmer writes or the user runs. Digital logic is based on the idea that general-purpose instructions can be modeled using nothing more than ones and zeros, but the ones and zeros must themselves be modeled somehow before they can turn into digits, logic, or characters on a screen.
Computers do one thing well...
At a literally nanoscopic level, a computer is little more than a collection of switches. Lots of switches, really: a few hundred per square millimeter in the Commodore 64's day, and millions per square millimeter using today's most advanced lithographic techniques. (tk footnote Moore's Law?) But unlike a light switch, the transistors used as switches in digital devices are not operated by physically flipping a conductor to complete a circuit. Transistors are solid-state electronics made of semiconducting materials that, depending on an input signal, either allow or prevent the flow of current through a junction. The difference between no current and full current is thought of as the difference between a zero and a one, a false and a true, or an off and an on.
As they are built largely from transistors, computers are devices that do one thing very, very well: they can detect the difference between no current and some current. Despite the power represented by making millions of simple decisions per second, this principle of operation also presents a problem. With no physical components to move and create or break a circuit, a single transistor will not "remember" whether it should be allowing current to flow or not without a constant input signal. Without that bit of memory, a transistor can only ever allow a signal to pass through it; if it is to be useful in logic, it must somehow be made to capture the output of that signal and combine it with the signals coming from other transistors on the chip to perform complex operations.
Memory and CPUs
Depending on which is best for the application at hand, there are several ways to construct a circuit around a transistor that will allow it to behave as a useful logical switch. The most basic is to simply offload that responsibility to another part of the integrated circuit. This approach is often taken in parts of a microprocessor that are intended to carry out the actual work of computing, such as the arithmetic logic unit (ALU). An ALU is a series of transistors organized into logic gates – simple circuits that compare two input voltages and produce an output based on comparing them to see if they are the same or different. (tk footnote Boolean logic) The simple logic gates are ganged together to allow multiple inputs to undergo relatively complex operations and produce multiple outputs. Within the gates, though, the data is simply used and then lost, transformed into an output.
In practice, an ALU is rarely complex enough to accomplish large tasks in a single pass. Since the logic gates must be reused to calculate the results of subsequent passes, storing the results of the first pass is relegated to an accumulator. The accumulator in the Commodore 64's 6510 chip is a memory register that holds the results of a previous calculation until they are fed back into the ALU as one of its inputs for a future calculation. This process, which takes place entirely at the level of transistors, is an iterative function: a process that repeats continuously, using the output of previous passes as an input for the next one.
Pushing storage off into a register does not truly solve the problem of how to make transistors remember states though; it only moves it to another part of the chip. Inside the registers is where the problem must be truly solved, and again the answer uses an iterative loop. The same logic gates that perform calculations in the ALU can be reconfigured into a circuit called a flip-flop. There are many different types of flip-flops, but what they have in common is that they use several transistors to create a positive feedback loop where the state of each transistor switch is reset every clock cycle to be equal to what it was in the previous cycle. An external voltage drives the entire loop and the state of the output is only changed when the state of an input changes. Though it appears from the outside that the state of the flip-flop is constant, the iterative cycle of setting a high or low output voltage based on whether the voltage was high or low in the previous cycle is what gets around the lack of a physical switch. (tk need to specify latches?)
Further away from the heart of the processor, another type of memory also uses iterative cycles to simulate a constant state. Dynamic Random Access Memory (DRAM) is a simpler but slower solution that uses far fewer transistors than the flip-flops in the processors. Instead, DRAM fills a capacitor with electrons to represent a high state. The capacitor quickly discharges though, returning it to a low state. Before it can discharge completely, control circuitry checks to see if it was full on the previous clock cycle and immediately refills the capacitor, effectively creating a loop that holds a state until the memory loses power.
"Go To Statement Considered Harmful"
In the case of 10 Print the GOTO statement avoids most of Dijkstra's complaints. Putting a GOTO statement at the end of a one-line program that simply references itself does not leave much room for unexpected entrances and exits. However, expanding the program to take more than one line demonstrates the potential problems that GOTO introduces:
5 CHARCODE%=205.5+RND(1) 10 PRINT CHR$(CHARCODE%); 20 GOTO 5
This code is functionally identical to the one-line version of 10 Print, but is a bit more representative of how developers create more complex programs. Line 5 creates a variable called CHARCODE% that stores a character code determined by the same formula used in the original 10 Print, but the character code is not used until line 10 when it is printed to the screen. Line 20 has the GOTO statement that makes the program iterate, but it now points to the new beginning of the program at line 5.
Already there is one potential problem: what if the programmer had forgotten to change GOTO's target from line 10 to line 5? The program would still function, but since the loop only returns to line 10 CHARCODE% never changes and the program only prints the same character over and over again with no randomization. Nowhere in this code does it say that the computer must select a random character code every time it prints a character, it is only implied by the fact that line 10 comes after line 5. GOTO allows the programmer to reference any line of code, however; it is just as valid to say GOTO 10 as it is GOTO 5, regardless of the intention that line 10 always executes right after line 5. GOTO's ability to target arbitrary line numbers means that sections of code that are intended to be monolithic can be entered at any point instead of just the beginning of the block.
GOTO's potential problems only get worse when it is combined with other flow control statements. Consider this variant of 10 Print:
1 FOR I = 0 TO 999 5 CHARCODE%=205.5+RND(1) 10 POKE 1024+I,CHARCODE% 15 NEXT I 20 GOTO 1
This version uses a FOR loop to fill the entire screen with the two 10 Print characters, beginning at the top-left corner. Immediately after finishing the FOR loop the program hits line 20 and GOTO sends execution back to line 1, restarting the loop from the beginning. If the forgetful programmer again fails to update line 20 though, leaving it as:
20 GOTO 5
The program will now not only fail to work as intended, it will fail to work at all and throw an error:
? NEXT WITHOUT FOR ERROR IN 15
Unlike the previous version where lines 5 and 10 were only implied to be a block, lines 1-15 are now explicitly a block of code defined as a FOR loop. NEXT relies on FOR, but since the block was re-entered on line 5 FOR never executes and NEXT is no longer valid. Using GOTO has short-circuited the other flow control structures that are critical to the language.
(tk may be clearer with diagram?)
Structured programming
Dijkstra's comments about GOTO were part of a movement toward programming languages that are designed for structured programming. Dijkstra himself would later take the idea further in his Notes on Structured Programming. Instead of viewing a program as line after line of text, structured programming practices involve seeing a program as an abstract set of tasks to be completed. Each of these tasks can be completed independent of one another; one section of the program can be written without worrying about how it is going to reference other sections because they share a common method of moving data between them. At a high level, programmers do not need to worry about how each function will work, they just know that it will and this knowledge allows them to plan their code strategically. Dijkstra compared this model to a string of pearls:
One of the metaphors in which I find myself thinking about the program structure envisaged regards the programs as a necklace, strung from individual pearls. We have described the program in terms of levels and each level contained "refinements" of entities that were assumed available in higher levels. […] I use the term "pearl" for [individual functions].
OOP
Recursion
Design and feedback
Iterative design
Testing as development
Agility and reuse
= Iteration – software and business=
Mechanical reproduction
Version 1.0
Break
Iteration as a Generalized Process
Bread and Beer
Fractals and Chaos
Life
Notes for Grid (Casey)
- As a visual work, 10 PRINT follows from Constructivism. . Started by Rodchenko . Unlike pre-ware utopian constructivism, post-war was about pure logic and systems for their own sake . Post-ware mostly European (focused in Paris, London, Zurich) . GRAV (including Morellet, Molnar) . Ad Reinhardt is a bridge in the US
- Working within a grid . Paul Klee with striking similarity . Francois Molar almost identical to 10 PRINT, including random selection (p. 212 in DATA) . Sol LeWitt worked with random elements in a grid
