I had begun to develop the concept for this work by attempting to represent incomprehensible scale via traditional computational methods, and while working with extremely large and extremely small numbers can be difficult, it's not impossible. The problem became that the further I moved toward the technical challenge, the less interested I became in the result. I reached a point at which I was simply expressing large numbers and this was clearly wrong direction because it's not the numbers themselves I'm interested in, but the implications of understanding the relationship between humans and the scales those numbers represented. I had become too concerned with creating precise number systems, when it was the lack of precision that I had become most interested in. The strength of computers isn't that they can represent precision, it's that they can approximate with a reasonable degree of accuracy in a very short time-frame. And by this I do not mean that they are inaccurate in the sense that we think of a clock with a flat battery as inaccurate, but that they are reliably and predictably inaccurate. This is due to a phenomenon called "round-off error". I had known that computers were only accurate to a specific decimal place, however I wasn't aware of the implications until I began to read T. J. I. Bromwich's book "An introduction to the theory of infinite series".
Bromwich explains the concept of computational round-off error as error that is introduced when a computer can no longer store a number in memory due to the size of the number exceeding the allowed storage space. Round-off error usually occurs as the result of preforming computational operations on very small floating-point numbers (that is, non-whole numbers) or very large integers. When an operation creates a situation in which there there is no more room to store the resulting number, it becomes impossible for the number to become more accurate by adding more digits. The solution is to round or truncate the result and while this seems simple enough, the danger is that numbers that have previously been rounded will be operated upon again, compounding the error. For example, if a number that has been rounded is multiplied, the error margin will be multiplied as well. There are solutions to minimizing round-off error, but I've become more interested in exploiting it. The concept that a number becomes more inaccurate the more accurate one tries to make it is contrary to my previous notions about computation. When this round-off errors are exploited they become a representation of the incomprehensible: Numbers so large or small that any error becomes impossible to resolve properly by machines whose purpose is simply to calculate.
This work is an exploration of repetition expressed in the form of an Infinite Series. The Infinite Series is a mathematical concept for the representation of a sum of a series of numbers in sequence (expressed as "1+2+3..."). An Infinite series may be generated algorithmically as in the case of this work as each line element in the center of the box moves vertically down toward it's destination at the bottom. The further it moves, however, the shorter it's next movement will be, and thus it will never actually reach the bottom because it's final state will be one in which the round-off error has eclipsed a single unit of movement on the screen. In this state calculations continue but are entirely fruitless as further calculation yields nothing more substantial, or less error-ridden, than the previous one and is clearly not useful as a function of movement any longer. The lack of a more useful result does not render the the calculations void, however, as it's very important to understand that they are still occurring, regardless of meaningful output, and they will continue until each element is "destructed" and removed from view entirely.
Conceptually, the work is similar to John F. Simon, Jr.'s "Every Icon" project in which he has attempted to generate and catalog every possible black and white icon within a thirty-two by thirty-two pixel grid. I was less interested in the results, or the implications of this sort of simulacrum (it will generate every picture possible, after all), but how it hinged on incomprehensible time-scales. Technological advances aside, projects of this kind take so long to complete that it's as near to "never" as makes no difference. My work is somewhat similar in that it tries to get at that area of indeterminate worth between accuracy and practicality; where the numbers begin to become fuzzy at a degree that does not matter for any useful purpose. However, also like "Every Icon", the work continues far beyond practicality. "Every Icon" is clearly not only about generating every 32x32 icon. On a practical level the difficulty isn't in generating the icons, it's deciding if a particular icon is usefully representational. Nearly all of the icons generated will be, more or less, garbage, but it's useful to understand how much noise is in a particular system and by what means it is manifested. The noise in my system is manifested by architectural and software decisions that were made before I was born. They are in every software program and on every computer in the world, and practices have been developed to mitigate the noise, where as I have deliberately set out to exploit it in the most obvious manner possible.
In considering the intended meditative qualities of my project, I immediately thought of Cory Archangel's "Super Mario Clouds". The most obvious component is nostalgia, and he's mentioned many times before that his works on the Nintendo system are obviously partly composed of pure kitsch. Cory's works and "Super Mario Clouds" in particular also seem to be about obsessive coding practices at a level that returns results transparent as as they are complex. It's clear to most programmers exactly what's going on behind the scenes in "Super Mario Clouds": It's a series of continual iterations, moving each cloud slightly, but structured in a way that the work will never cease (until someone presses the "Power" button, of course). This is obviously subverting the notion of video games in which there is a stated and usually obvious goal and in addition to the removal of traditional game-play elements, "Super Mario Clouds" is also entirely non-interactive. Its only intent is to be observed, and while this seems again like a subversion of the Nintendo as a video game system, it's also just as true of nearly all computational devices. Computers are without reason and purpose, and it's only the will of people that drives them. Without the initial seed of human interaction, there is nothing useful to compute. And of course the work was not created without Cory's intervention, but it does continue without it in a similar fashion to my work. It provides a means to observe the machine in a particularly simple state of computation in action. Likewise, my project creates a similar situation in which the viewer may attempt to understand the mathematical principals driving the display purely by observation. Observation, however, presents the viewer visualization that functions as a meditative aid by virtual of it's repetition in a similar manner to the "Super Mario Clouds" display.
The need to continue to watch isn't in the hope that something spectacular will happen is, I believe, rooted in the desire to confirm that nothing spectacular has happened, is happening, or will happen. The viewer wants to confirm their suspicions about the piece by seeing it to completion and feeling vindicated when it seems to conform to their assumptions. It doesn't take long to realize, though, that this isn't practical. The work will never, effectively, be over. Hopefully this realization then gives way to reflection about the nature of such projects, and the understanding that the completeness is not what is required either of the work, or the viewer.