Is anyone working on these problems, or did people just give up?
It's crazy to think that the way we create and consume software barely changed since the 60s/70s.
It's crazy to think that the way we create and consume software barely changed since the 60s/70s.
In terms of creating software, in the 1960's most was being written in Assembly and if it was written in a higher level language that language almost certainly contained a large proportion of vendor specific instructions or was entirely proprietary or machine specific. That didn't change much in the 1970's and it was only at the end of the 1980's that language standards could practically mean portable code across vendors and platforms.
But you're still writing 'text' to manipulate 'data'. An example of something fundamentally different would be if you can make programs without text. I intentionally said make not write to avoid framing the discussion. For instance why write `(circle 10)` when you can instead just draw a circle and then perhaps define processes to manipulate it? I don't mean code generation - why even have text as the canonical form that describes computation processes?
It's a sort of fluid evolution where I can always be in control.
It would be a hard time doing that via visual programming.
Also you could have a timeline that shows you what got changed instead of comparing two text files. There can be lots of ways to achieve the same goal, understanding what changed and how, than just diffing two text files.
Don't you really want to do more meaningful comparisons though? I think text is a poor form for versioning and comparison because you always have to mentally extrapolate the textual diff (lines added/deleted) to the syntactic diff (functions added/deleted/modified) to the diff in effect (which logic in which systems is modified). There is no reason other forms of programs cannot also do diffs, that could be more useful.
Visual does't have to mean flowchart boxes. Even a tree structure might be incrementally better than plain text.
but there is no inherent reason why text is better at this than visual programs. it's just that people haven't done it, which is the issue. everyone just assumes text is the natural way to interact with a computer, but yet most people forget they went through a lot of training, formal or informal, to get to that perspective. and one could argue that comparing text is not as good as comparing the differences between visual programs because the latter actually contains structure and relationships of how things are called more readily.
what you describe with two side-by-side windows of the same VI (i.e., function or code block or whatever) is exactly something that i have done with labview. a better visual comparator is not beyond reach.
Nobody says that books kinda suck and should be replaced by pictographs on papyri, but somehow many programmers at least have a phase when they think that having to program by drawing shapes could somehow be easier than writing textual code...
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?
Because before you get to machine code, you’ll want to transform to an expression tree, and text is an excellent accessible way to represent that. The text form might be an IR with various graphical or other non-text (and possibly some text) source languages, though.
Here’s an example of visual programming. All you’re really doing there is chaining together functions and tuning parameters, but instead of typing, you’re dragging wires around and twiddling knobs.
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've yet to encounter a more precise and usable input mechanism than the keyboard. > You can also imagine more effort into displaying code in a less textual manner, even if the keyboard remains the primary input.
I agree the keyboard is definitely a great 'high bandwidth/fidelity' input mechanism and I don't see it being easily replaced. Can we use it to manipulate something other than 'text files'? As a simple incremental improvement, manipulating a tree like structure directly comes to mind. I'll note that the powerful operations in most text editors already use models that treat the text as something more structured than a 'sequence of lines'.
> how can I express (circle (/ height 2))? The second expression is where programming gets interesting.
I don't imagine text being completely eliminated at all levels, but a hybrid model where you could have many views of the same 'literal'. E.g. something like http://aprt.us where you can draw an object, but then also fiddle with it's parameters in another inspector - including binding those parameters to other inputs. I imagine you'd also also have snippets of text here and there, or occasional text views of objects.
> But plain text has a nice advantage over these: it's always clear how to reproduce what you see.
This actually a valid point and I hadn't thought much about it. Perhaps the trust is just a result of the current situation where text cloning (copy-pasting) is reliable, but object cloning is either impossible or hacky. If I could drag a diagram off a wikipedia page, manipulate its parameters and integrate it with my program - that would be something.
> 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
Yes! Interestingly that model isn't widely used either. An interesting generalization of this could be an 'interactive' programming experience - where I try to compose two artifacts and the computer offers N options to do that composition, based on what it knows about the artifacts and known constraints. Then I narrow them down by selecting one or adding more constraints, etc. Type checking is very clunky and rigid form of doing composition that IMO forces me to do too put in too much effort of the wrong kind.
> Symbolic computation has the possibility of doing something and then telling the programmer why it did what it did.
This does sound interesting and touches on another issue I have with the systems today, that they require me to simulate the computer in my head too often (while sitting in front of a computer, ironically). I suppose light table like tools are trying to solve the problem, but there is a broader problem in that the surrounding infrastructure is not conducive to such tools - many interesting things I'd want to see are buried in secret file formats and internal in-memory structures of the compilers and runtimes.
> A graphical object is one example, but what if we could do that for all kinds of output?
Yes that would be awesome!
> Maybe textual output is problem, not textual programs?
As are 'hidden' representations that I have to mentally simulate. Ideally I want to see not just the immediate program I'm manipulating (text or otherwise) but also the implications - the affected parts of various other intermediate representations all the way to the running, live system that will be affected.
It’s just that we don’t know how. Even designing a good text based language is very challenging, and in no way a solved problem. Something graphical and interactive has a much larger design surface, and is thus even harder to get right, especially for general purpose programming.
The incentive exists for the shareholders, but they are not the ones making hiring decisions and choosing tools for programmers to use.
There's a regular meetup group in San Francisco:
Outside AT&T walls, strong type systems programming did actually exist.
And here are we now still looking towards to somehow fix it, and it will take several generations.
It is domain-specific and their current promotional material makes it look like an expanded DAW a la Ableton Live, but you can develop all kinds of software in Max, not that you necessarily should.
https://2017.splashcon.org/track/live-2017#Call-for-Papers
Jonathan Edwards submitted something I like and HARC (checking out Sean his submission now), MS Research are doing cool things.
I wanted to go there. Next time perhaps; interesting work anyway.