Bret Victor

Welcome to the first post of the new Vidéothèque series of De Programmatica Ipsum. In this new section, we would like to share with you what we consider the best videos available online about programming, the history of computing, software development, architecture, and other related fields. Video as a communication medium has grown unprecedentedly in the past 15 years; in this section, we will propose the most relevant among many classics.

The first video of this series will feature none other than Bret Victor in one of his most memorable moments. We have already discussed Bret in a previous article about Smalltalk, where we named him one of the most influential figures in that galaxy. This video, however, shows that his light shines much brighter than that.

In a mind-twisting experiment, Bret Victor takes us back to July 1973. His demeanor, dress code, and even the mechanism by which he illustrates his words–an overhead projector, of all things–all take us back in time. Bret took attention to the slightest details, like the pens in his shirt pocket. Or even his haircut. And most of all, his words, like greeting peers as “programmers of automatic computing machines” in all seriousness.

Together with form, there is content.

His initial thesis (easily verifiable) is that people’s thinking evolves slower than technology. He goes to show how every big evolution in programming (from binary to assembler, from assembler to FORTRAN, and then from language to language) is met with contempt or resistance, in the worst cases, hostility.

Bret goes on to explain four major ways programming could evolve, as seen from the point of view of a hypothetical researcher in the early seventies.

Or, put another way, showing us what the future used to look like.

• From coding to directly manipulating data, explaining Ivan Sutherland‘s Sketchpad (1962);
• From procedures (“how”) to stating goals and constraints (“what”,) showcasing Carl Hewitt‘s Planner system (1969,) Alain Colmerauer‘s Prolog (1972,) Ralph Grisworld‘s SNOBOL (1962,) Ken Thompson‘s regular expressions (1967,) and J. C. R. Licklider‘s “Intergalatic Computer Network” as examples;
• From plain text to graphical and spatial representations of programs, following the steps of Douglas Engelbart‘s legendary NLS System (1968,) T. O. Ellis‘ GRAIL project (1968,) and Larry Tesler‘s Smalltalk;
• From sequential to parallel programming, highlighting the limits of the Von Neumann architecture, the impact of the Intel 4004 microprocessor (1971,) and Carl Hewitt’s Actor Model (1973.)

Of course, the sad conclusion (or funny, depending on how you see it) of this video is that our industry has not fully evolved in any of these directions. Well, maybe the last one did happen (somehow, through multicore architectures and Erlang) because as Herb Sutter said, the free lunch was over around 2002. But as Bret mentions around the 16th minute, we still lack services that can figure out how to talk to each other by themselves, leading to a brittle world of interconnected microservices, breaking every so often and fueling a whole market of observability and management tools.

Yet, here we are.

I’m totally confident that in 40 years we won’t be writing code in text files. Right? We’ve been shown the way.

(Minute 20:33… and listen to another memorable quote at minute 26:07 that I will let you discover.)

Most of the code we put in production is written in linear text form, compiled or interpreted, and painfully validated, verified, and evaluated by various (human and automated) mechanisms. Except for some visual environments, mostly used to create GUIs, sometimes using the Cassowary linear constraint algorithm, most developers are still using their keyboards as a primary input method. GitHub Copilot just feeds that experience further; having an automated mechanism spitting unrelated code snippets stolen elsewhere will not, in the opinion of this author, change the status quo substantially in the long run.

In short, the experience of programming, the one you, dear reader, live day in and day out in your daily job, has not fundamentally evolved in the past 60 or even 70 years. Our command line environments even have the TTY (short for “teletype”) moniker embedded in them. We are still coding… procedures… in text files… using sequential models.

We grew up, as programmers, learning only one way to do things, and considering it immutable. That is Bret’s definition of a tragedy and the final conclusion of this stellar talk.

The video is available on YouTube for your watching pleasure. And if this is not enough (I bet it will not be) just check the portfolio of Bret’s work on his website.

Cover snapshot by the author.

Continue reading Geoffrey G. Parker, Marshall W. Van Alstyne, & Sangeet Paul Choudary or go back to Issue 048: Evolution. Did you like this article? Consider subscribing to our newsletter or contributing to the sustainability of this magazine. Thanks!