Lambda the Ultimate

That seems to me to be a very limited way of looking at things. We can write a formula to describe something in eleven dimensions -- try doing that visually.

[Edit2 - old topic "Good Point, sorta"] Nevermind, looks like the wee hours also addled my reading - that's a horrible point. Math, as I will show is a fantastic example of a 2d language. Matrices even look kinda like this guy's conditional stuff. Perhaps there is a misunderstanding about what 'visual language' means. It doesn't mean there's no text - it means that the text is nonlinear, and additional nonascii constructions may be included.

(originally I thought he was trying to say that 11-dimensional diagrams would theoretically be better than 2-dimensional diagrams, by my logic)

Sorry, I figured that what I meant was implicit in the post. Or perhaps it's just because I wrote it at the wee hours of the night when I forget people can't read my mind.

Anyway, a big part of it is that our visual centers of the mind are very powerful pieces of equipment - they do huge amounts of parallel processing behind the scenes. The combination of reading Edward Tufte's books and Steven Pinker's "How The Mind Works" is probably necessary for really grasping this, and other cooler stuff :)

This power is somewhat leveraged with the programming practices of indentation and similar expression alignment.

Sure, you can write math in a 1-dimensional language such as latex, but mathematicians hate it - math is 2d! Ever wonder why subscripts, superscripts, multiplication, and higher order parameters all use 2d juxtaposition and scaling? It's because mathematicians have found a concise, understandable syntax which takes advantage of the freedom rendered by existence on a 2 diminsional surface.

[EDIT] A part i forgot earlier is that 2-dimensional code allows for more than two spatial connections. In 1d you can only go backwards and forwards. Languages that utilize carraige return for 2d-ness would be awkward if they actually used 2d location for relations. 2 dimensions allow for many connections between components without overlaps. A good illustrating example is the function call - each expression is slotted into a parameter. However, each successive parameter is further and further away from what it goes into. 2d layout helps to fix this problem by allowing parameters to be positioned around the function call. One way languages get around this is naming things - local variables, parameter names. These are good, but much of the time they are redundant with the type. Another way, as seen in a few languages, is to go purely compositional, combintators and all.

I think your view is the limited way of looking at things. You have used ascii all your life, and can't see the possibilities beyond it.

As you can see, I've thought about this a lot. At least a year or two, and normal language design for quite a few years before that. (though recently I've beeen thinking about the possibilities of agent-based parsing...)

All those lines you see are just one big line with newlines thrown in.

I am probably missing a smiley here, but

  (/ (* (- 2 3)
        (+ 4 1))
     (+ 11 3))

seems quite two-dimensional to me.

(Example by Guy Steele)

Other examples include indentation-based languages like Haskell and python.

The thing is, that's just how it's stored - the common display of text is 2d. A png is just a 1d stream of bytes. Every file on your computer is.

I agree with you, though, in essence text is 1d in regards to the connections that you can reasonably make between elements. You could have semantics which depend on the locations of symbols up/down with eachother, but it'd be a horrible language - you'd always be aligning and adjusting stuff. (no this isn't a slight against pythonic indentation - I'm talking about where you actually need 2d alignment between multiple elements per line)

The key observation is that text is a subset of the syntax a visual language might have. I think good visual languages will mostly be text, with no non-semantic visual elements (gradients, thick borders, etc).

The images are all at the end of the pdf, a poor layout, unfortunately not so rare when the paper is made in LaTeX..

Images at the end of a file isn't really a LaTeX issue: it's easy to place images inline in LaTeX, or on pages of their own interleaved with the text. More likely, it has something to do with whatever journal the author is submitting to. Some journals require submissions to include all figures at the end of the text. [Edit: I have no idea what OOPSLA's requirements are like. I suppose another possibility is that since this is a draft, he hasn't quite figured out where to stick the figures yet]

From the paper:

The diagrams ... have been placed at the end of the
paper so that they can be torn off and followed separately.

To be honest, this was my first foray with latex, taken under duress. The advice I got was that cross-column figure placement would be torturous, and I would probably not be able to get it perfect. My reviewers preferred them at the end. It seems that not everyone agrees. The PC will have the last say.

The images are actually the most exciting part. The later examples are particularly awesome. I probably wouldn't have gotten so much out of the text alone.

Somewhere in the middle, things get generalized so that some overlap is allowed (but it must ultimately be resolved). So Dijkstra's guarded conditionals indeed cannot be implemented. But that is an explicit design choice of the author, which needs to be justified. What better justification method than to contrast with a famous but opposite decision? [That was my point, which I did not make so well, apparently].

I should be explicit that I am focusing only on deterministic conditionals. I like your perspective that Dijkstra uses overlapping to express non-determinism, while I am interpreting it as erroneous ambiguity. Interesting contrast. Thanks.

This is not my insight, I learned it from various colleagues (probably a combination of Tom Maibaum, Alan Wassyng and Ryszard Janicki, with always a little of David Parnas thrown in for good measure).

And it is important to understand that Dijkstra uses it for non-determinism, and never for under-specification. Those two concepts are easy for people raised on deterministic programming to confuse, but are in fact quite distinct.

... Dijkstra uses overlapping to express non-determinism

I'd rather say that Dijkstra's use of non-determinacy makes overlapping meaningful. But there is more to his non-deterministic conditional construct (and loop) than just this. In Dijkstra's
   if b₁ -> a₁ [] b₂ -> a₂ ... fi
or
   do b₁ -> a₁ [] b₂ -> a₂ ... od
the order of evaluating the guards b_i is irrelevant to the meaning of the construct, so the construct effectively specifies no-order, not excluding concurrent evaluation. This kind of non-determinacy is valuable in itself, and it is independent of the one present in the choice of an action when there are more than one overlapping true conditions.

As for your schematic table approach, I find it interesting and wish you success in developing it.

While we are mentioning guarded commands (sorry Jonathan), I was struck by the passage in EWD418 where Dijkstra points out that gcd may be thought of as synchronizing two processes (x:=x-y, y:=y-x) subject to the constraint that x and y remain positive.

This was undoubtedly meant to be reminiscent of synchronizing two processes, a producer and a consumer, subject to the constraint that the queue between them is always somewhere between empty and full — at which point the usual mod operation becomes a context-switch minimization optimization.

I would not be too surprised if had it also been supposed to be reminiscent of computing by synchronizing two processes: an applicator to produce expressions, and an evaluator to consume them, subject to the constraint that the graph between the two is always somewhere between empty and full — where the value of full influences the eagerness or laziness of the resulting calculation.

Has anyone investigated the concurrent variant of guarded commands in which an if ... fi with no valid guards, instead of being equivalent to abort, was considered to have no currently valid guards and hence would be a rough dual to do? (instead of looping until no guards matched, it would yield until at least one guard matched)

I believe concurrent constraint handling rules do exactly what you want. A Concurrent Constraint Handling Rules Semantics and its Implementation with Software Transactional Memory uses exactly GCD as an example.