# Jovian Prayer

Big slow storms of Jupiter, help sooth us.
Sooth us with your patient weather, ochre,
gamboge, carmine, grey, swirling storms, giant.
And auroras, lightning, huge, cathartic.

Let us be like Galileo’s nameless
daughter, who threw herself into your heart
wrapped in curiosity, down, down, down,
swallowed by knowledge, by your huge brown storms.

# The Fetishist

Slow mottled gray skies, the empty plains
somewhere in the blown out corridor from
Houston to Galveston. Highway and plane
noise, far enough for privacy but frisson-
near enough for wanderers to run, run
the risk of observation, forced sight:
so much more than the dead camera, glum
in its facile adsorption of light.
An old abandoned pool languishing right
behind an encroached upon foundation,
obscenely, a chimney still stands, a blight
within a blight within a blight within station-
ary air. He mugs against the gray sky
and falls into shit for the camera’s eye.

# On Inform 7, Natural Language Programming and the Principle of Least Surprise

I’ve been pecking away at Inform 7 lately on account of its recently acquired Gnome front end. For those not in the know, Inform (and Inform 7) is a text adventure authoring language. I’ve always been interested in game programming but never had the time (or more likely the persistence of mind) to develop one of any sophistication myself. Usually in these cases one lowers the bar, and as far as interactive media goes, you can’t get much lower, complexity wise, than text adventures.

Writing a game in Inform amounts to describing the world and it’s rules in terms of a programming language provided by Inform. The system then collects the rules and descriptions and creates a game out of them. Time was, programming in Inform used to look like:

Constant Story "Hello World";
Include "Parser";
Include "VerbLib";
[ Initialise;
location = Living_Room;
"Hello World"; ];
Object Kitchen "Kitchen";
Object Front_Door "Front Door";
Object Living_Room "Living Room"
with
description "A comfortably furnished living room.",
n_to Kitchen,
s_to Front_Door,
has light;


Which is recognizably a programming language, if a bit strange and domain specific. These days, writing Inform looks like this: (from my little project):

"Frustrate" by "Vincent Toups"
Ticks is a number which varies.
Ticks is zero.
When play begins:
Now ticks is 1.

The Observation Room is a room. "The observation room cold and
surreal. Stars dot the floor underneath thick, leaded glass, cutting
across it with a barely perceptible tilt. This room seems to have been
adapted for storage, and is filled with all sorts of sub-stellar
detritus, sharp in the chill and out of place against the slowly
rotating sky. Even in the cold, the place smells of dust, old wood
finish, and mildew. [If ticks is less than two] As the sky cuts its
way across the milky way, the whole room seems to tilt.  You feel
dizzy.[else if ticks is less than four]The plane of the galaxy is
sinking out of range and the portal is filling with the void of
space. It feels like drowning.[else if ticks is greater than 7]The
galactic plane is filling the floor with a powdering of
stars.[else]The observation floor looks out across the void of space.
You avert your eyes from the floor.[end if]"

Every turn: Now ticks is ticks plus one.
Every turn: if ticks is 10:
decrease ticks by 10.



As you can see, the new Inform adopts a “natural language” approach to programming. As the Inform 7 website puts it

[The] Source language [is] modelled closely on a subset of English, and usually readable as such.

Also reproduced in the Inform 7 manual is the following quote from luminary Donald Knuth:

Programming is best regarded as the process of creating works of literature, which are meant to be read… so we ought to address them to people, not to machines. (Donald Knuth, “Literate Programming”, 1981)

Which better than anything else illustrates the desired goal of the new system: Humans are not machines! Machines should accommodate our modes of expression rather than forcing us to accommodate theirs! If it wasn’t for the unnaturalness of programming languages, the logic goes, many more people would program. The creation of interactive fiction means to be inclusive, so why not teach the machine to understand natural language?

This is a laudable goal. I really think the future is going to have a lot more programmers in it, and a primary task of language architects is to design programming languages which “regular” people find intuitive and useful. For successes in that arena see Python, or Smalltalk or even Basic. Perhaps these languages are not the pinnacle of intuitive programming environments but whatever that ultimate language is, I doubt seriously it will look much like Inform 7.

This is unfortunate, because reading Inform 7 is very pleasant, and the language is even charming from time to time. Unfortunately, it’s very difficult to program in1, and I say that as something of a programming language aficionado. It’s true that creating the basic skeleton of a text adventure is very easy, but even slightly non-trivial extensions to the language are difficult to intuitively get right. For instance, the game I am working on takes place on a gigantic, hollowed out natural satellite, spinning to provide artificial gravity. The game begins in a sort of observation bubble, where the floor is transparent and the stars are visible outside. Sometimes this observation window should be pointing into the plane of the Milky Way, but other times it should be pointing towards the void of space because the station’s axis of rotation is parallel to the plane of the galaxy. The description of the room should reflect these different possibilities.

Inform 7 operates on a turn based basis, so it seems like it should be simple enough to create this sort of time dependent behavior by keeping track of time but it was frustrating to figure out how to “tell” the Inform compiler what I wanted.

First I tried joint conditionals:

  When the player is in the Observation Room and
the turn is even, say: "The stars fill the floor."


But this resulted in an error message. Maybe the system doesn’t know about “evenness” so I tried:

  When the player is in the Observation Room and
the turn is greater than 3, say "The stars fill the floor."


(Figuring I could add more complex logic later).

Eventually I figured out the right syntax, which involved creating a variable and having a rule set its value each turn and a separate rule reset the value with the periodicity of the rotation of the ship, but the process was very frustrating. In Python the whole game might look, with the proper abstractions, like:


while not game.over():
game.describe_location(player.position);
if (player.position == 'The Observation Room' and
game.turn() % 10):
print "The stars fill the floor."


Which is not perhaps as “englishy” as the final working Inform code (posted near the beginning of this article) but is much more concise and obvious.

But that isn’t the reason the Python version is less frustrating to write. The reason is the Principle of Least Surprise, which states, roughly, that once you know the system, the least surprising way of doing things will work. The problem with Inform 7 is that “the system” appears to the observer to be “written English (perhaps more carefully constructed that usual)”. This produces in the coder a whole slew of assumptions about what sorts of statements will do what kind of things and as a consequence, you try a lot of things which, according to your mental model, inexplicably don’t work.

It took me an hour to figure out how to make what amounts to a special kind of clock and I had the benefit of knowing that underneath all that “natural English” was a (more or less) regular old (prolog flavored) programming environment. I can’t imagine the frustration a non-programmer would feel when they first decided to do something not directly supported or explained in the standard library or documentation.

That isn’t the only problem, either. Natural english is a domain specific language for communicating between intelligent things. It assumes that the recepient of the stream of tokens can easily resolve ambiguities, invert accidental negatives (pay attention, people do this all the time in speech) and tell the difference between important information and information it’s acceptable to leave ambiguous. Not only are computers presently incapable of this level of deduction/induction, but generally speaking we don’t want that behavior anyway: we are programming to get a computer to perform a very narrowly defined set of behaviors. The implication that Inform 7 will “understand you” in this context is doubly frustrating. And you don’t want it to “understand,” you want it to do exactly.

A lot of this could be ameliorated by a good piece of reference documentation, spelling out in exact detail the programmatic environment’s behavior. Unfortunately, the bundled documentation is a big tutorial which does a poor job of delineated between constructs in the language and elements of it. It all seems somewhat magical in the tutorial, in other words, and the intrepid reader, wishing to generalize on the rules of the system, is often confounded.

Nevertheless, I will probably keep using it. The environment is clean and pleasant, and the language, when you begin to feel out the classical language under the hood, is ok. And you can’t beat the built in features for text based games. I doubt that Inform 7, though, will seriously take off. Too many undeliverable promises.

1 This may make it the only “Read Only” programming language I can think of.

# Prime Industrial Space

In their enthusiasm, they built roads
(huge, wide things, six lanes or more, sidewalks)
for which they had no buildings, through forest,
or through meadow. But to drive them, empty
and spacious, is a kind of luxury.
You have passed from, at fifty miles per hour,
reality; prime industrial space.

And into what? At an empty crossroad,
kids have knocked down the “road closed” barriers,
the black circles of their tires crossing,
crisscrossing, looping across that square of
white concrete. With the barriers down
you can drive right through to where the road ends,
leave your car, and walk through dirt, to the woods.

# Strange Truths, Spoken Plainly

Black holes are cold,
or so I am told.
And the bigger,
the colder.

So voracious
and unspacious,
they must take it,
all in, all in.

Even heat.

When the universe
gets cold enough,
(meaning old enough),
they’ll let it all out,

in a trickle,
that might tickle,
anyone patient
enough to wait.

# Compose is Better than Dot (or: Function Level Programming In Javascript)

That great minds think alike is a reflection of the fact that certain ideas have an appeal that is, if not innate, then compelling in context. Hence the use of dot notation in the creation of domain specific languages in Javascript: dot is a handy way of succinctly representing a computation with a context. This is closely related to monads, and many javascript libraries relying heavily on dot for syntactic sugar are very closely related to one monad or another (eg _ to the sequence monad, promises to a sort of continuation monad, etc).

(NB. Much of the code here is inspired by a pointfree/function level programming library I am building for Javascript called puff, available here);

What I aim to prove today is that function composition subsumes the functionality of dot in this regard and that we can embed in Javascript a powerful, succinct function-level programming language in the vein of APL, J, or K/Q based primarily on function composition.

First of all, the traditional definition of function composition:

/** compose functions
*  return a new function which applies the last argument to compose
*  to the values passed in and then applies each previous function
*  to the previous result.  The final result is returned.
*/
function compose(){
var fs = Array.prototype.slice.call(arguments, 0, arguments.length);
return function(){
var inArgs = Array.prototype.slice.call(arguments, 0, arguments.length);
var i = fs.length-1;
var res = fs[i].apply(null, inArgs);
i = i - 1;
for(; i>=0; i = i - 1){
res = fs[i](res);
}
return res;
}
}


This version of compose allows the programmer to pass in an unlimited number of functions and returns a new function which takes any number of arguments and then threads the result through all the previous functions, transforming it each time, starting with the last function and ending with the first.

This order of composition is inspired by the fact that the function in a traditional application expression precedes the argument (on the left), transforming:

f(h(g(o)))


“naturally” to

compose(f,h,g)(o)


or, if succinctness is of interest:

var c = compose;
c(f,h,g)(o)


In this way we drop a few parentheses and hopefully express more clearly our intent.

Of course we might not wish to apply our composition immediately: we can produce useful functions via composition, after all.

var plusOne(x){ return x + 1 };
var timesTen(x){ return x*10 };

var plusOneTimesTen = c(timesTen, plusOne);


We can now apply plusOneTimesTen to as many values as we wish. Handy. However, now our intuition about naming and the order of the arguments to c are at odds. Hence, we introduce:

function rCompose(){
return compose.apply(null,
Array.prototype.slice.call(arguments, 0, arguments.length).reverse());
}
var r = rCompose;


So that the above looks a bit nicer:

var plusOne(x){ return x + 1 };
var timesTen(x){ return x*10 };

var plusOneTimesTen = r(plusOne, timesTen);


This reverse composition operator is similar in many respects to dot in javascript except we have abstracted away this, to which each method invocation is implicitly addressed in a dot chain. In addition, instead of simple method names, each element in our r list can be any Javascript expression which evaluates to a function. This means that we can denote any sequence of operations this way without worrying whether or not they have been associated with any particular Javascript object.

With the right set of primitives and combinators, r forms the basis of a powerful, succinct function level programming language in which we can build, among other things, expressive domain specific languages. Or with which we can rapidly denote complex operations in a very small number of characters.

Well, first of all we want the bevy of basic functions:

plus, minus, div, times, split, join, toString, index, call,
apply, etc, array


These behave as you might expect, more or less (eg, some plausible implementations to give you the spirit of the idea):

function plus(){
var out = arguments[0];
Array.prototype.slice.call(arguments, 1, arguments.length)
.forEach(function(x){
out = out + x;
});
return out;
}

function index(o, i){
return o[i];
}

function call(f){
return f.apply(null, Array.prototype.slice.call(arguments, 0, arguments.length));
}


You get the idea.

Astute readers may realize that our composition function seems to only work with functions of a single argument. Remedying this will be a matter of some interest. The simplest approach is to provide for partial application:

/** partially fix arguments to f (on the right)
*
*/
function partialRight(f /*... fixedArgs */){
var fixedArgs = Array.prototype.slice.call(arguments, 1, arguments.length);
var out = function(/*... unfixedArgs */){
var unfixedArgs = Array.prototype.slice.call(arguments, 0, arguments.length);
return f.apply(null,unfixedArgs.concat(fixedArgs));
}
out.toString = function(){
return "partialRight("+f.toString()+","+fixedArgs.join(",")+")";
}
return out;
}

/** partially fix arguments to f (on the left)
*
*/
function partialLeft(f /*... fixedArgs */){
var fixedArgs = Array.prototype.slice.call(arguments, 1, arguments.length);
var out = function(/*... unfixedArgs */){
var unfixedArgs = Array.prototype.slice.call(arguments, 0, arguments.length);
return f.apply(null,fixedArgs.concat(unfixedArgs));
}
out.toString = function(){
return "partialLeft("+f.toString()+","+fixedArgs.join(",")+")";
}
return out;
}


These functions (they might be adverbs in J) take a function and a set of values and return a new function, “fixing” the arguments to the left or right of the argument list, depending on whether we’ve usedpartialLeft or partialRight.

Its handy to introduce the following bindings:

var p_ = partialRight;
var _p = partialLeft;


I hope these are relatively mnemonic (Javascript unfortunately isn’t an ideal environment for very short, expressive names).

We can get a surprising amount of mileage out of these ingredients already. For instance, a function to remove break tags from a string and replace them with newlines (sort of contrived):

var remBreaks = r(p_(split,'<br>'),p_(join,'\n'));


compared to

function remBreaks(s){
return s.split('<br>').join('\n');
}


(NB. If split and join are written as curried functions, as they are in puff, the above is a little shorter:

var remBreaks = r(split('<br>'),join('\n'));


Providing a meaningful default currying (which args should be applied first) is a little tricky, though.)

## Going Further

The above example demonstrates that we can do some handy work with r as long as it involves simply transforming a single value through a set of functions. What may not be obvious here is that a determined programmer can denote any computation whatsoever this way, even if multiple values might need to be kept around and transformed.

Consider the function which I will call augment or au:

/** given a function f and a additional functions gs
*  return a new function h which applies each g
*  to its single argument and then applies f to the
*  resulting list of values
*/
function augment(f /*... gs*/){
var gs = Array.prototype.slice.call(arguments, 1, arguments.length);
var out = function(a){
return f.apply(null, gs.map(function(g){
return g(a);
}));
}
out.toString = function(){
return "augment("+f.toString()+","+gs.map(toString).join(", ")+")";
}
return out;
}


And a nice default currying of index:

function index(o, ix){
if(typeof ix === "undefined"){
var realIx = o;
return function(o){
return o[realIx];
}
} else {
return o[ix];
}
}
var ix = index;


Now:

var fullName = augment(join(' '), ix('first'), ix('last'));


Such that:

fullName({first:'Ronald',last:'Reagan'}) -> "Ronald Reagan"


What have we just accomplished? We’ve demonstrated that we can take an arbitrary function of any arity and automatically transform it into a function which reads its input arguments from a single object. The sort of single object which we might be passing from function to function via r.

## Putting it Together

To go further we need to add just one more utility function: cleave

function cleave(v /*... fs*/){
var fs = Array.prototype.slice.call(arguments, 1, arguments.length);
return fs.map(function(f){
return f(v);
});
}


and the shortcut:

function cl_(){
return function(f){
return cleave.apply(null, [f].concat(Array.prototype.slice.call(arguments,0,arguments.length)));
}
}


(This is just cleave curried on the right, eg in puff: c_(cleave).)

// replaceMiddleName name newMiddleName -> transformedName
var replaceMiddleName = r(args(2),
cl_(r(first, split(' ')), second),
cl_(r(first,first),second,r(first, third)),
au(join(' '), first, second, third));


Let’s go nuts with some of the extra utility functions in puff:

var replaceMiddleName = f(2,
cl_(r(n0,split(' ')),n1),
cl_(n00, n1, n02),
join(' '));


Puff lets you do all of this insanity quite easily. There are browser and nodejs builds. You use it by saying, in node:

require('puff').pollute(global);


Which pollutes the global namespace with the puff functions. Since terseness is the rule I can’t imagine why you’d do otherwise, but you can also say:

var puff = require('puff');
puff.r(...)


<script src="./build/puff-browser.js"></script>


To your head. This will define a global puff object, which you can then use directly or say:

puff.pollute(window);

# Skunks

Skunks

All this burning and yet still sodden world:
each day, raising smells like the underside
of lavender, dust and slate, my dry mouth.

They are, each day, ever more abstracted,
white and black coarse fur, driven by car wheel
ever more towards lumps of tufted pink gore,
then to brown, strangely flat things, dirt, dust.

Vincent Toups

# Buzzards

I think nothing so honest
exists as the huge buzzard,
that which rots, to eat bowels,
to eat the soft grape of dead eye.

Luxuriously, they glide,
one by one, enormous winged
black birds, to perch on the corpse,
or to dance, wings outstretched,
around it on the dead grass.

We are trussed buzzards, bound tight,
just a hop from some big corpse,
rotted now, nearly perfect,
tender, fragrant. If we could
just slip our bindings to feast.

# The Fox

Amen I say to you: the fox which lives
in the abandoned building near our cabin
means nothing at all. It bears no portents.
Molecule by molecule it tumbles
through space, much like the rest of us, a dense
cloud, a dense cloud, a dense cloud of
matter whispering itself the quiet
evocations of its own being! Or!

Maybe not.

It is brown. It stares at us silently,
while we sit there in our car watching it.
It is the brown of dead leaves, wet from rain
in late December, of mud, of the wood
of the empty building near our cabin.

# The Deer Corpse

“Some hunters dumped a corpse out on your land,”
she says, “I tried to catch them, but they slipped past me.”
We smelled it, of course, while we walked to shake
the last persimmons from the naked, wild trees.

In the cold, the smell was mild, even
complimentary, to those sweet, sticky
brown fruit, whose pulp stained our hands and jeans red,
where we squeezed it out, wiped it, eating.

Later, I saw its rib cage, bone white, resting
in a copse of wood. Insects had stripped it
mostly, but had then been arrested by
the cold of winter. Its limbs were askew.

One foot still had skin and fur. The hoof black.
In it, I saw the living thing, the deer,