Remarks: Ports to Other Platforms

From Maze

(Difference between revisions)
Jump to: navigation, search
(→Diagonals)
(Total rewrite of this material.)
Line 1:Line 1:
−
== Patterns ==
+
Thanks to its simplicity of construction and of form, 10 Print is easy to appreciate as an aesthetic object. This experience takes place on several registers. To name a few: as a visual experience running on a Commodore 64, a line of computer source code, and as the relationship between those two. To appreciate ''10 Print'' fully, a viewer must consider all of these registers and perhaps even more.
−
===Variations on a Maze: 10 Print as CHR calls===
+
There's another way to reflect on ''10 Print'': by reimplementing it in different ways. The most obvious reimplementations take place on the C64, by changing the original program in modest or significant ways. But many other methods of variation and reimplementation are possible, including considering the way mazes work in other programs and recreating ''10 Print'' on totally different platforms. At first blush such effort might seem like mere geekery, but a closer look shows that these variations can tell us much about the nature of the program.
−
[this was moved from mazes chapter needs to be modified)
+
===Commodore 64 Variations ===
−
This section examines a set of simple variations in the ''10 Print'' one-liner, each drawing on different graphic characters from the PETSCII table. Although each change is small, every variation has a significant impact on the perceived maze-like qualities of the visual output. The output of ''10 Print'' has a unique visual appeal, which we can understand in terms of design and composition (diagonal vs orthogonal), and in terms of how it plays against the contextual expectations of the historical period when it emerged (graphical software -- particularly video games of the era).
+
When a C64 user first keys in and runs ''10 Print,'' he or she may soon wonder how the pattern might change if it used different character set instead of the slash characters. Whether through experimentation with different numeric values or by consulting a PETSCII table to find promising graphic characters, such changes are quite easy to accomplish.
−
When we attempt to change even the smallest element of ''10 Print'', we make an interesting discovery -- ''10 Print'' is a kind of optimal solution that is uniquely elegant in its design space (a c64 BASIC one-line maze generator). Any similar attempt is both less concise (requires more code) and less expressive (resembles a maze less). In fact, the concision of the code and the expressiveness of the image are tightly related, and arise out of a unique set of constraints and interactions:
+
It turns out that even small changes have a significant impact on the visual output, particularly on its status as a maze-like pattern. The output of ''10 Print'' has a unique visual appeal, which we can understand in terms of design and composition (diagonal vs orthogonal), and in terms of how it plays against the contextual expectations of the historical period when it emerged (graphical software -- particularly video games of the era).
−
* the keyboard layout of the PET / C64 ('''moved to c64 chapter''')
+
When we attempt to change even the smallest element of ''10 Print'', we make an interesting discovery -- ''10 Print'' is a kind of optimal solution that is uniquely elegant in its design space (a c64 BASIC one-line maze generator). Any similar attempt is both less concise (requires more code) and less expressive (resembles a maze less). In fact, the concision of the code and the expressiveness of the image are tightly related, and arise out of a unique set of constraints and interactions, particularly the interaction between the desire to constrain the program code to a single line and the sequence of adjacent characters in the PETSCII table.
−
* the sequence of adjacent characters in the PETSCII table
 
−
* graphic design and topology
 
−
* a design goal to make the one-liner short and simple
 
−
Because the original program is a concise randomized offset to a region of the PETCSII character table, our variations are limited to other such lookups. The code is limited by the characters available in PETSCII, and the concision or elegance of the code is affected by the adjacency of characters, which must otherwise be randomized in a more complex way than an offset.
+
Because the original program is a concise randomized offset to a region of the PETCSII character table, let's consider only variations that embrace the same limitation.
−
 
−
 
−
=== Diagonals ===
 
−
 
−
[[Image:10print-diagonal.png|160px|thumb|10 PRINT CHR$(109+RND(1)*2); : GOTO 10]]
 
−
 
−
By contrast, the maze output of 10 PRINT is oriented diagonally, giving it a distinctive visual look.
 
−
 
−
Several things about this visual orientation are surprising. First, when we visually trace the maze the long runs or paths that lead through the maze do not follow the lines along which the algorithm constructs the maze (which remains left-right, top-bottom). Second, this feature of being diagonal is not an elaboration in the code, but instead an elegant simplification that is part of the essence of the succinct one-liner.
 
−
 
−
<blockquote>10 PRINT CHR$(109+RND(1)*2); : GOTO 10</blockquote>
 
=== Orthogonal Weave ===
=== Orthogonal Weave ===
Line 31:Line 17:
[[Image:10print-orthogonal-weave.png|160px|thumb|10 PRINT CHR$(102+RND(1)*2); : GOTO 10]]
[[Image:10print-orthogonal-weave.png|160px|thumb|10 PRINT CHR$(102+RND(1)*2); : GOTO 10]]
−
There are no other two characters in the [http://en.wikipedia.org/wiki/PETSCII PETSCII] data set that, when substituted for our "\" and "/", will result in the construction of a traditional orthogonal maze. Vertical and horizontal bars, for example, result in a disconnected weave, while solid and empty squares result in rough static.
+
There are no other two characters in the [http://en.wikipedia.org/wiki/PETSCII PETSCII] data set that, when substituted for "\" and "/", will result in the construction of a traditional orthogonal maze. Vertical and horizontal bars, for example, result in a disconnected weave, while solid and empty squares result in rough static.
<blockquote>10 PRINT CHR$(102+RND(1)*2); : GOTO 10</blockquote>
<blockquote>10 PRINT CHR$(102+RND(1)*2); : GOTO 10</blockquote>
−
(add note on 3d wicker visual interpretation)
+
Though it's certainly not a maze, this version of the program imparts a three-dimensional impression, as if someone had woven bands of material over and under one another.
=== Corners ===
=== Corners ===
Line 41:Line 27:
[[Image:10print-elbows.png|160px|thumb|10 PRINT CHR$(108+(INT(RND(1)+.5)*3)); : GOTO 10]]
[[Image:10print-elbows.png|160px|thumb|10 PRINT CHR$(108+(INT(RND(1)+.5)*3)); : GOTO 10]]
−
Randomly selecting corner pieces such as "L", on the other hand, simply turn the image into a honeycomb.
+
Randomly selecting corner pieces such as "L", by contrast, turns the image into a honeycomb.
As it turns out, diagonal mazes are symbolically efficient on a Cartesian grid due to the fact that four characters meet at the corners, whereas only two meet along an edge. Thus, intersections of up to four lines (the building blocks of a rectilinear maze) can be created at corners if we use diagonal lines.
As it turns out, diagonal mazes are symbolically efficient on a Cartesian grid due to the fact that four characters meet at the corners, whereas only two meet along an edge. Thus, intersections of up to four lines (the building blocks of a rectilinear maze) can be created at corners if we use diagonal lines.
Line 69:Line 55:
<blockquote>10 PRINT CHR$(181+(INT(RND(1)+.5)*3)); : GOTO 10</blockquote>
<blockquote>10 PRINT CHR$(181+(INT(RND(1)+.5)*3)); : GOTO 10</blockquote>
−
== See Also ==
 
−
* [[10_Print_in_a_visual_context]]
+
===PATH: Maze as Program===
−
* [[Visual_Essay]]
 
−
* [[Cultural_History_of_Mazes]]
 
−
== Notes ==
+
While computer users may think of programming languages as relatively straightforward instruments used to produce increasingly complex or efficient tools and experiences, ''10 Print'' shows that the code itself can have aesthetic features worthy of consideration on their own merit.
−
Cross-reference the discussion of QWERTY / PETSCII with a small table of textures that indexes the variations, giving each a letter pair, index pair, a name, and a picture:
 
−
* FG (102/103) Weave
+
A small but lively group of programmers rejects the values of clarity and efficiency in programming, in favor of other code aesthetics. While some of these techniques rely on the exploitation of conventions in existing, "normal" programming languages, others involve the invention of entirely new languages with their own aesthetic properties. These "esoteric" or "weird" languages test the limits of programming language design and comment upon programming languages themselves.
−
* JK (106/107) Waves ?
 
−
* NM (110/109) (reversed) Maze
 
−
* OP (111/112) Corners2 ?
 
−
How should the table be sorted? Probably by alphabetical / index, although it doesn't make sense to go through it in that order.... Table might also have two pictures -- one of the textured render, the other of the symbolic render (-32 shifted, so NM etc.) There is a hotkey in C64 BASIC to do this...?
+
Many weird languages comment on the practices of programming, but the sort Michael Mateas and Nick Montfort dub "minimalist" comment on the space of computation itself. As they put it, "Minimalist languages strive to achieve universality while providing the smallest number of language constructs possible. Such languages also often strive for syntactic minimalism, making the textual representation of programs minimal as well." The archetypical minimalist language is Brainfuck. It provides seven commands, each corresponding to a single character of punctuation.
−
*[http://www.commodore.ca/manuals/c64_programmers_reference/c64-programmers_reference_guide-02-basic_language_vocabulary.pdf c64 Programmers reference guide]
+
Another style of weird language uses a two-dimensional space to hold a program's instructions, rather than the usual organization into lines of code. One such example is Piet, a language whose source code resembles abstract paintings (like those by its namesake, Piet Mondrian). Another is Befunge, which uses typographical symbols like <, v, and ^ to move program flow.
−
* Potential illustration for IF sidebar
+
−
** [http://ifarchive.giga.or.at/if-archive/mapping-tools/maps/varic.jpg Map of Varicella]?
+
PATH is a weird language that borrows from the conventions of Brainfuck and Befunge, offering a syntactically constrained language whose control flow takes place in a two-dimensional space.
−
** [http://www.youtube.com/watch?v=YeV0pLRyM7o MC Frontalot ''It is Pitch Dark'' @2:38]
+
−
*Porting / Reimplementation as Translation vs. Adaptation
+
PATH has a natural connection to ''10 Print'' because the language uses the / and \ characters for program flow. / and \ are reflectors. As the program counter travels around in 2D space, it bounces off the reflectors in the intuitive way. Here's a path program that computes nothing (but moves
−
** [http://jeremydouglass.com/cv/benchmark.pdf Benchmark fiction]?
+
the PC around).
 +
 +
<pre>
 +
/ \
 +
$ / /
 +
</pre>
 +
 +
Control starts at the dollar sign and flows to the right. It bounces off the first reflector and goes up, then bounces right, then down, then left then down (and at this point would flow off the edge, terminating the program).
 +
 +
In addition to / and \, PATH uses v ^ < > to move the flow conditionally, down, up, left and right,
 +
respectively, if the current memory location is non-zero. Memory locations are arrayed on an infinite tape Turing style, and you can increment and decrement the current memory focus.
 +
 +
Given PATH's strong typographical similarity to ''10 Print,'' it's possible to implement a version of ''10 Print'' in PATH--a program that generates labyrinths by endlessly walking a labyrinth. Here's what such a PATH program looks like:
 +
 +
<pre>
 +
10 print chr$(109+rnd(1)*2); : goto 10
 +
 +
$ \
 +
/ /
 +
\ + } } } } } + } } + } } + } + } + } + } } } + } + \
 +
/ /
 +
\ } +++++++++++++++++++++++++++++++++++++++++++++++ \
 +
/ /
 +
\ } ++++++++++++++++++++++++++++++ \
 +
/ ++++++++++++++++++++++++++++++ /
 +
\ ++++++++++++++++++++++++++++++++ \
 +
/ {{{{{{{{{{{{{{{{{{ /
 +
!
 +
/ \
 +
/ - { \ / - { \ / - { \ / - { \
 +
\} } } } } } } v }^ { !/ !\ !/ { v }^ { !/ !\ !/ { v }^ { !/ !\ !/ { v }^ { !/ !\ !/ \
 +
{ { { {
 +
\ } ^ + { / \ } ^ + { / \ } ^ + { / \ } ^ + { /
 +
/ /
 +
 +
/ - { \ / - { \ / - { \ / - { \
 +
\ { v }^ { !/ !\ !/ { v }^ { !/ !\ !/ { v }^ { !/ !\ !/ { v }^ { !/ !\ !/ v !/ \
 +
{ { { { \ - /
 +
\ } ^ + { / \ } ^ + { / \ } ^ + { / \ } ^ + { /
−
=== Additional Images ===
+
/ {{{{{{{{ v }}}}}}}} /
 +
\ {{{{{{{{ \
 +
/+ \ /+ { \
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ v }}}}}}}}} ^ !/ {{{{{{{{{ !\ !/ } v }}}}}}}}} ^ !/ {{{{{{{{{{ !\ !/ \
 +
/- / /- { /
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }}}}}}}}} ^ / \ }}}}}}}}} ^ /
 +
/ /
 +
/+ {{ \ /+ {{{ \
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }} v }}}}}}}}} ^ !/ {{{{{{{{{{{ !\ !/ }}} v }}}}}}}}} ^ !/ {{{{{{{{{{{{ !\ !/ \
 +
/- {{ / /- {{{ /
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }}}}}}}}} ^ / \ }}}}}}}}} ^ /
 +
/ /
 +
/+ {{{{ \ /+ {{{{{ \
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }}}} v }}}}}}}}} ^ !/ {{{{{{{{{{{{{ !\ !/ }}}}} v }}}}}}}}} ^ !/ {{{{{{{{{{{{{{ !\ !/ \
 +
/- {{{{ / /- {{{{{ /
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }}}}}}}}} ^ / \ }}}}}}}}} ^ /
 +
/ /
 +
/+ {{{{{{ \ /+ {{{{{{{ \
 +
\{{{{{{{{{ \ \{{{{{{{{{ \ !
 +
\ }}}}}} v }}}}}}}}} ^ !/ {{{{{{{{{{{{{{{ !\ !/ }}}}}}} v }}}}}}}}} ^ !/ {{{{{{{{{{{{{{{{ !\ !/ \
 +
/- {{{{{{ / /- {{{{{{{ /
 +
\{{{{{{{{{ \ \{{{{{{{{{ \
 +
\ }}}}}}}}} ^ / \ }}}}}}}}} ^ /
 +
/ /
 +
\ }}}}}}}} v }}}}}}}}} . !/ {{{{{{{{{{{{{{{{{ /
 +
\ }}}}}}}}}} . { /
 +
</pre>
 +
 +
And here's the output it produces when run:
 +
 +
<pre>
 +
\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\//\\///////\\/\\\/\//\///\\\\\\/////\\\/\/\//\\/\/\\////\\///\\/\////\\\\///\\\//\\\\/\\\//\//\\//\\/\\/\\\\//\/\/\\\/\\\\\\\\/\\/\//\\\////\/\/\//////\/\\//\\\/\\//\/////\////\//\\\\\/\/\\\\/\///\/\//\/\\\///\///\//\//\/\///\\//\/\\/\/\/\/\\/\\///\/\\\\\/
 +
</pre>
 +
 +
Amusingly, the output of ''10 Print'' is itself a PATH program, just one that only moves the
 +
program counter around, doing no other work.
 +
 +
 +
===Processing===
 +
 +
''10 Print'' produces an appealing visual effect. As such, it deserves the name "visual art." While computer artists have used code to make visual compositions for decades, since the turn of the millennium interest in computer-generated visual art has expanded rapidly within the digital art community. Some use widely-available commercial tools like Flash for this purpose, while others have built bespoke programming environments designed specifically for visual artists.
 +
 +
John Maeda's _Design by Numbers_ (2001) offers one example, but a far more popular and influential tool is Ben Fry and Casey Reas's Processing, which was inspired by Maeda's work and created under his research group at the MIT Media Lab. Processing is really just Java, with a specialized toolkit, program framework, and authoring environment laid atop. Among its goals, Processing seeks to introduce non-programmers to the practice of programming, but it also offers a set of very simple tools (such as mechanisms for drawing and coloring lines and shapes) for the creation of generative visual art.
 +
 +
That lineage in mind, implementing a version of ''10 Print'' in Processing allows us to focus on its visual design in a way that might not be easy or even possible to do in a C64 program. In the Processing version of ''10 Print'' depicted here, the program is created by drawing a left or right-facing diagonal line within a grid of enclosing squares.
 +
 +
[Need to add image of Casey's Processing implementation]http://mailman.mit.edu/mailman/private/10-print/attachments/20100505/92aa360e/Picture-1-0001.gif, http://reas.com/rnd/
 +
 +
Already that's a different way to think about the visual output of the program, since the C64 version simply outputs characters to the screen buffer, which wraps them in order to create the appearance of a maze. But Processing programs also tend to rely on code rather than assets to create their effects. That is, Processing is particularly adept at visual renderings produced entirely from geometric primitives fashioned in source code rather than from loading and manipulating image files (although it is certainly capable of the latter). When using such a technique, it is easy to make small variations on the appearance of individual elements in the output by changing the values of particular variables in the program.
 +
 +
The adaptation of ''10 Print'' shown here offers several knobs that can be used to alter the appearance of the individual cells, among them thickness, randomness, and shape. Changing the shape used for individual cells from slashes to circles or lines results in the same sort of systemic visual changes seem in the Commodore 64 variations discussed above. However, changing the thickness or randomness of the pattern results in a totally different appearance, as shown below.
 +
 +
[Image of some variations]http://mailman.mit.edu/mailman/private/10-print/attachments/20100505/92aa360e/Picture-2-0001.gif, http://mailman.mit.edu/mailman/private/10-print/attachments/20100505/92aa360e/Picture-3-0001.gif
 +
 +
Generative art is characterized by the use of algorithms or self-automated processes to create some artistic result. From an author's perspective, the practice of creating generative art is less a matter of designing a fixed, singular outcome than in designing a machine capable of producing a variety of different outcomes. ''10 Print'' is itself generative--it uses a set of instructions to create a visual effect. But as the C64 variants suggest, the manner of parametric variation possible on that platform, within a single line of BASIC code, are limited. The Processing variant of the program is not only many more lines of code, but also far more granular in its settings. When discussing generative aesthetics, it's common to think that more parametric variation is "better"--or at least more generative--than less variation.
 +
 +
That value in mind, the Processing program's results suggest a question: were one to create or discover ''10 Print'' as a Processing program instead of a Commodore 64 one-liner, would the particular configuration of settings that correspond with the latter seem most natural or appealing? It's impossible to answer definitively, but the question does underscore how the constraints of the original program's authorship--a single line of code, the particularities of the PETSCII table, and so forth--contribute to the result partly by reducing its possible variations, rather than by increasing them.
 +
 +
 +
=== Additional Images (what were these here for?) ===
[[Image:Game-Pac-Man-arcade-(1980).png|left|thumb|160px|''Pac-Man'' (1980 arcade) -- a maze-like field of partitions must be run while being chased by ghosts]]
[[Image:Game-Pac-Man-arcade-(1980).png|left|thumb|160px|''Pac-Man'' (1980 arcade) -- a maze-like field of partitions must be run while being chased by ghosts]]
Line 102:Line 184:
−
== Bibliography ==
+
== Bibliography (not sure which of these are still in scope here) ==
''Commodore 64 User's Guide''. Wayne PA; Indianapolis, IN: Commodore Business Machines; Distributed by Howard W. Sams & Co., 1982. <http://www.commodore.ca/manuals/c64_users_guide/c64-users_guide.htm>.
''Commodore 64 User's Guide''. Wayne PA; Indianapolis, IN: Commodore Business Machines; Distributed by Howard W. Sams & Co., 1982. <http://www.commodore.ca/manuals/c64_users_guide/c64-users_guide.htm>.
Line 114:Line 196:
Latham, Aaron. "Video Games Star War." ''The New York Times'' 25 Oct 1981: 100+.
Latham, Aaron. "Video Games Star War." ''The New York Times'' 25 Oct 1981: 100+.
 +
Mateas, Michael and Nick Montfort. "A Box, Darkly: Obfuscation, Weird Languages, and Code Aesthetics." In Digital Arts and Culture: Digital Experience: Design, Aesthetics, Practice (DAC 2005), Copenhagen, Denmark, 2005.
 +
Map of Twisty Little Passages All Alike Maze. TEXTFILES. <http://www.textfiles.com/adventure/mazmap.adv>.
Map of Twisty Little Passages All Alike Maze. TEXTFILES. <http://www.textfiles.com/adventure/mazmap.adv>.

Revision as of 16:58, 31 July 2011

View this revision of Remarks: Ports to Other Platforms.

Personal tools