The Future of Programming (2013)

I've yet to encounter a more precise and usable input mechanism than the keyboard. I've played a bit with drag-and-drop programming environments, and they've gotten a lot better, but it's hard to be as expressive and it's hard to be as efficient.

That said, the input in The Mother Of All Demos (https://en.wikipedia.org/wiki/The_Mother_of_All_Demos) maybe did improve over the keyboard, what with multi-button mice and single-hand cording keyboards. But it's not a setup people have engaged with much since then.

You can also imagine more effort into displaying code in a less textual manner, even if the keyboard remains the primary input. There are even fonts that do this in a small way (turning >= into ≥, for instance). But plain text has a nice advantage over these: it's always clear how to reproduce what you see. There's no hidden information. There's no display bug that renders structure invisible (except perhaps bad indentation). Text can be trusted. The one visual overlay we use – syntax highlighting – is more like a checksum than an augmentation.

Another possibility is to have a richer set of literals, like you suggest with a drawn circle. The drawn circle is not unlike any other object, it would have parameters, an in-memory and serialized representation. And it would have its own mini-editor of sorts. But how many constants do you need in a program? Not many in my experience. At first this made me think about JSX – which is modestly a more expressive form of JavaScript – but then I realized: what makes JSX special is that the code and HTML are mixed together. JSX and React are a kind of refutation of limited template systems. How do you draw a circle with size S and color C? I can express (circle 10) in concretely, but how can I express (circle (/ height 2))? The second expression is where programming gets interesting.

Sketchpad (https://en.wikipedia.org/wiki/Sketchpad) is kind of interesting here, as my impression was that what made it special wasn't just the interactive graphics but that it was a constraint-based system, where the drawn figures could be interpreted and adapt to other environments, as they had both fixed and flexible sides. In a sense you were creating models, and those models were turned into concrete drawings.

I think there's probably a better expression of programs than text, but it's going to require something more different than what we've thought of so far.

My own inkling is that the Wolfram Language might have something in it. Maybe Symbolic Calculation (https://en.wikipedia.org/wiki/Symbolic_computation) is an aspect of it. Symbolic computation has the possibility of doing something and then telling the programmer why it did what it did. Like, imagine I have some program that makes a picture:

    (repeat (i 50)
      (transpose 
        (color (circle (* i 0.5))
               (- 1 (/ i 50)) 0 i)
        (* i 10) 0)

I.e., it lays out a line of circles that grow in size and change from red to blue. Except I messed it up, I didn't get the blue argument to (color) correct. You can imagine a language where the circles weren't bitmaps, you were really making objects, and those objects know how and when they were made, they are just expansions of expressions. So I could inspect one of those overly-blue circles, and I can see the expression that made it, the value of i at the time it was made, and how each part of the expression evaluated as it formed the circle. That would be pretty nice! A graphical object is one example, but what if we could do that for all kinds of output? Maybe textual output is problem, not textual programs?

Finding new semantics for constructing computational logic is certainly a good middle-of-the-road innovation.

The philisophical underpinnings of my own research and practice over the past decade are in constant existential friction with many of the most basic assumptions that underlie information theory. I've argued about it on here before. Since I'm terrified of general AI developing under the current power-dynamic, I haven't been too enthusiastic about contributing.

That said, a lot needs to be disbelieved-- we need an ideological grass fire on the great plans, of sorts-- before certain types of phenomenon can be reliably conjured through our electrical counting machines.

We've mistaken the representation with the thing itself, especially in the 'information sciences.' The idea of 'information' and 'data' as 'packets' presupposes the existence of a physical world composed of neatly delineated objects. While this has been and continues to be a convenient and even useful approximation of reality, it is still that-- a representation.

I've never seen this assumption questioned Im CS/IS forums. At this point, it's beyond dogma.

The unbelievable volume and density of the knowledge built in the information sciences, all of it sewn into these base assumptions of information theory, generate in the unwitting practitioner a belief considered as a hard-as-bedrock fact, always presumed but never questioned. It's confirmation bias propping up a simulacra of reality.

Like physics did last century, our latest IS works (like general AI) are hitting the hard limit on these assumptions.

What's next? Try deconstructing it yourself. That's part of the fun, and helpful in the creative process.

In the mean time It would be nice to see new ways of visualizing code and code execution, that's probably a good start.

Code in Motion – An Interstellar Inspired Visualization for the JVM - https://vimeo.com/96317948 Code Galaxies Visualization - http://anvaka.github.io/pm/ Binary data visualization - https://news.ycombinator.com/item?id=15164166

> books (text) are still the main medium

Geometry books don't use text as the only form of communication. Neither do books about architecture, mechanical engineering, anatomy, circuit design, etc. Imagine a world where you used only text to convey all these ideas and their relationships. Computer programming today a bit like that. Why should we assume that pure text is the best and only suitable form for representing automatic computation?