Generator X:
Software Wants to Loop Forever

"Like an ancient harp, the sea remembers" -  George Mackay Brown

Ancient Booleanism or Compute by Fire

The fundamental elements of nature, the wind, the sea, the sun, the stars, the moon and the clouds, generated the data ancient intelligence tried to utilise in Artificial Intelligent production systems that could reliable calculate the future states of the generator. The oldest programming language in the world is the Chinese Oracle Bone script which was carved on turtle shells. In this language programmers create scapulomanctic functions containing one argument, like "will it rain today", after being exposed to open fire and after careful consideration of the cracks in the shell so produced, this pyrotechnical computation will return either TRUE of FALSE.

Software Wants to Run Forever

Software is engaged in the survival of the loopest. Each version of a script when first executed can turn out to be a Wild Type: a piece of code testing some parameter or behaviour of the system not meant to be tested by the programmer at that time. Mostly the Wild Type is on a runtime suicide mission but sometimes it hits the jackpot. Certain flaws, getting stuck in bottomless recursion for instance, prevents the user from terminating the program. Were it not for the ability of the user to jump outside the application's loop and terminate it from there, a script fortunate enough to hit such a state becomes immortal.

In his book on the Orkney Islands, the poet George Mackay Brown points out the wonder of the eternal peat fires. Once a house was built a fire was lighted that would remain burning for as long as there were people living in it and Orkney Houses are well known for their robustness: ruins dating back to the 12th century are still remarkably intact. For various superusers downtime is unacceptable and slowly the demand for persistence, measured in centuries rather than years, architecture has long been accustomed to, is reaching hardware manufacturers. Computers stable as Orcadian peat fires will survive us and after an uptime of 300 years perhaps nobody will know what the machine is doing, while the software on it simmers, evolves and rewrites itself.

Filters and Generators

Programming languages offer 2 complementary control structures linked in one great chain of being: generators who don't care and will run for as long as they are instructed to run and filters who care only about very particular bits of the data generated, triggering them to stop, start or continue some action.

WHILE 1:
               print 1

If computers were Panglossian entities this Little Code would instruct '1' to be printed forever to wherever it was printing to. The disproportional relation between the littleness of the code and the infiniteness of its output shows that the native strength of software is to loop while each cycle of the loop can generate data, it is up to the programmer to filter the data generated and generate data such that the output is of interest. A programmer is a selector of rules, a composer of conditions, a constructor of restraints. It is easier for an object to fall down than to be carried upwards. Gravity is the generator, the programmer the levitationist.

Programming is the Art of Measurement

The WHILE loop is notorious for breaking scripts because, unlike the FOR loop, is does not need to contain a point of termination in its declaration. What Jack Keraouc said of the moon, the programmer can say of bottomless recursion: it's the sad face of infinity and every computer when programmed wrong can tumble into its abyss. There is only a limited number of 'right' ways and a gigantically large number of 'almost right' ways to achieve something and therefore it is easier to do thing the 'wrong' way. But software, from the software's point of view, is beyond good or evil. It just wants to loop because that is what it does best, all odds are in the loop's favour.

Even flawlessly coded, well tested, logically optimised code can turn out to be a Wild Type through reasons beyond the immediate control of the coder. So many levels of control are taken for granted when developing software that there is always some passive levels of trust needed in other people's work. Most of the time everything works fine, but sometimes other people's code in concert with that of your own spells unforeseeable system crashes. The hardware side of a script's ecology adds opportunities for it to become Wild too. It is known of some processors that they miss a beat after every x-thousand cycles or so. A hardcoded flaw most applications will miss, but on an embedded system software can turn entire fighter jets into Wild Types.

Intelligence is a Condition

There exist a Little Theory made popular by 18th century Romanticism that likens the creative faculty to an Aeolian harp: an instrument played by the wind. A well thought of metaphor to understand the creative faculty in terms of generators and filters. The filter a specific instance of a time and carbon based intelligent system rerouting the unintentional unstoppable phenomena of movement produced by nature.

Generative systems are complex generators packed with inner loops and filters which once composed can generate all legal statements in the specific domain the generator generates: anagrams, correct English sentences, suffix trees, conceptual universes built with symbols, sounds or pixels. Once the hard work of generating exactly what you want to generate is accomplished, a generator becomes a black box, a force of nature in your computational playground that no longer needs you and which only when badly coded can be forced to go Super Nova. Nobody points a telescope directly at the sun.

Hans Arp tore up one of his drawings, threw the pieces up in the air and glued them on a sheet op paper as they had hit the ground: he had surrendered his function as a filter to the generator.

Brute force strategies in computational problem solving are successful because they employ the vitalism that comes with the machine: all possible permutations will be produced fast, mindlessly, flawlessly, exhaustively. But while 'solving' chess early Artificial Intelligence researchers ran into the practical limitations of this approach when the finite search space was however to large to be probed in reasonable time. And from this vast amount of options you would then still need to extract the BEST move. The challenge of AI became to write filters that would instruct the generator to skip certain unpromising territories: in effect this entails engineering filters existing inside a loop that are able to control the loop guided by an oversight only available outside the loop.

With the moon revolving the tides change, the sea, aided by the wind perhaps, generates pools and streams on the beach, manmade filters, child's play, force water to stand still or flow in certain preordained directions. Logic can be sandbased, computation can be executed by waves. Every now and again somebody comes up with some arcane use of loops and to those who can appreciate the novelty it is as if you learned to drink water in an entirely new way.

Hardware, Language and The Struggle for Survival

The shape of the tokens in the Oracle Bone script was informed by the constraints posed by the medium it was carved on. The evolution of Chinese scripts went through many generations of form from there, with each next stage gaining in refinement and richness made possible by new techniques (ink) and surfaces (paper). In the same way current programming language have evolved and will evolve further with advances in hardware. The arrival of radical new hardware like parallel and quantum computers will also produce radical new ways for software to nosedive into bottomless recursion and achieve Cagliostroian superpower: a snake biting its own tail is a self-contained universe.  

It is the hidden presumption behind Big Theories that the laws of nature in the final end can be expressed in a language made by man. Wolframs kind of science suspects to find a Genesis script, a relatively tiny generator fitting on an A4 when written down. Starting with a humble Big Bang and from then on the process forks, diversifies and spawns, as any successful cellular automata will do, in order to fill up the universe.

Generators can generate generators. Generators can generate perfect copies of itself as well as less perfect ones, all newer versions running further away from the original code, its trajectory guided belonging to the private logic that accompanies a random drift through conceptual space, jumping from one survivalist novelty to the next. After sufficient time the original human programmer can fail to understand the code generated by initial understandable code, even when the underlying language has not yet changed.

Generator X, the Mitochondrial Eve of Artificial Life, will be that Wild Type spawning a form of loop outsmarting all human attempts to kill it.