(Note: I started this post yesterday shortly after you posted, ljk, and it's taken me all that time, working on it a little bit at a time, to hack together this much. Be careful what you ask for...)

No, I hadn't, although I've enountered the term "artilects" in an AI context. Thanks for the link--I've been meaning to look into the term deeper.

I have a hazy recollection of Doc Lanning's soliloquoy. It's sort of the spirit of the thing, though concepts he's tossing around are a bit simplistic. Goes cinematically mystical at the end on the subject of the soul...and there I don't think I'll tread. Just trying to grapple with consciousness and reality (and their possible relationship) is plenty of stress on my skull for now. Possibly forever.

I've been mulling over the problem of explaining the deep abstractions of programming for a while now, maybe a couple of months, but I'm still working on it. It's really a tough problem. I especially started thinking about it after reading Leonard Susskind's The Cosmic Landscape, which does an excellent job communicating a sense of modern cosmology. After I finished I thought to myself that Susskind could probably grasp my abstractions, but I would need to write a book like Susskind's to communicate a sense of it to others. You can see already I have a hard time getting this across...but there was a congruity somehow in the way that the "things" or "spaces" I construct in a computer have dimension (in my mind's eye) and behavior and characteristics which are determined by the starting conditions I "sculpt" with my source code. My source no more looks like what I create than an equation looks like the universe; between symbol and reality is the mapping I'm having trouble explaining.

A reference point is the basic concept of computing that everyone has, which is so Newtonian it dates back to Charles Babbage and his literally mechanical Engine in the mid 1800s. You write up a linear sequence of instructions, load them into the machine, start up the machine in a blank state and let the sequence of instructions advance the machine from one state to another, and when the instructions are exhausted, you turn it off and read the result in the final state of the machine. A century later (1949) Alan Turing described a theoretical abstraction of a computer he called a "Turing Machine", in an equally mechanistic formal description.

Nothing about that description even remotely matches the modern practice of programming.

Consider that programs don't "execute" like that. You start them running, and usually leave them running all day. Business people leave Excel or Word open all day while they work on many documents. Windows runs constantly. My Web server software runs constantly, unattended, which required me to build in self-checking and diagnostic and recovery routines (might I venture to say that such software is a little bit "self-aware"?). Software now exists. Instead of being executed, it "lives".

Running software has a length along the dimension of time because it pesists. In some ineffable sense this running software also occupies "space". It can be partly quantified in terms of a quantity of memory. But that's a misleadingly crude measure. A block of memory is a planar two-dimensional space, yet the software organizes out of that substrate constructs that have multiple dimensions; these constructs occupy a virtual "volume" of a "space" that's an abstraction of a two-dimensional plane.

One of the simplest of these constructs is also most analogous to cosmology: Multidimensional arrays. We build them with any arbitrary number of dimensions, and much like the posited dimensions of a universe, some of those dimensions may be bounded and finite, others may be infinite. In a recent multimensional array I designed, the first two dimensions were infinite, each slot (quantum) corresponding to a subscription in a two-dimensional matrix of events (event handlers "subscribe" to particular events to respond to them). The third dimension had a fixed length, as each final array in the matrix was a fixed-length record of the subscription. I called it a "2.5 dimensional Engine".

I tossed in the word "quantum" there. Did I note that the digital world is entirely quantized? The length of a dimension of an array of data is measured in integral multiples of the size of the data it contains. Aha! Data has size too. It occupies a space measured in integral numbers of bits.

Another kind of dimensionality in programming is to be found in interfaces. Much of what was recently considered modern programming practice, Object-Oriented Programming, is concerned with defining standard interfaces between software components so that they can "plug-n-play". I liken OOP-style interfaces to big thick SCSI cables, because they define whole objects, an array of functions "on" the object, and the arguments to each of those functions. Counting on my fingers...let's see, that's a three-dimensional interface: Functions, arguments, size of the arguments to the functions.

OOP is too big and clumsy for the lightweight designs I need for Web pages, so lately I've been working on an architecture more like lots of little fiber-optic or USB cables than fat SCSIs, connecting together a lot of little gadgets, restricting myself to a two-dimensional interface based only on functions. By enginering my interfaces to fit into fewer dimensions, they work more efficiently. I'm engaged in dimensional engineering.

At the same time, to wring more efficiency out of the restricted environment of a Web browser, I'm folding space. That is, I'm continually breaking down big blocks of code into smaller ones, abstracting the common code and putting it in libraries and throwing out the redundancy. The function once done by two separate blocks of code is done by two blocks of code that now, in a sense, share an overlapping space. Intriguingly enough, as time goes on, my software gets smaller, partly because I'm tucking bits of it away in odd corners of space (remember the flying car/spaceship of Heinlein's later novels, that could contain vastly larger volumes of space within itself than its outer dimensions? It's like that...sort of.) In terms of information theory, this process continually increases order in my software "universe" and decreases entropy.

What's the common term for a process which decreases entropy?

I took me a day to hammer together that...well, all that, whatever you'd call it. It's still not true, but it's closer to true than I've gotten so far. Do I sound like a raving mystic or what?