# Bret Victor, 'The Future of Programming' (DBX, 30 July 2013)

- Speaker: Bret Victor
- Event: DBX conference (Dropbox), San Francisco
- Date: 30 July 2013
- Length: 32 min 55 s
- Video URL: https://vimeo.com/71278954 ; https://www.youtube.com/watch?v=8pTEmbeENF4 ; references: https://worrydream.com/dbx/
- Slides: About 40 overhead-projector transparencies, hand-placed, each with one image or one line. Played as a period piece set in 1973.
- Transcript source: Whisper (faster-whisper, model medium) on the archive.org mirror; cross-checked against the timestamped transcript at glamour-and-discourse.blogspot.com. Timestamps match the Vimeo video.
- Corrections: Correction applied to the machine output, checked against the published transcript: 'if 40 years' to 'if in 40 years' (26:06).
- Format: `[mm:ss]` is the time the line starts in the source recording. Machine transcript: expect small word errors; quotes used in the analysis were checked against the published text where one exists.

---

[00:06] Good afternoon.
[00:22] I'm really excited to be talking to so many programmers of automatic computing machines.
[00:28] As you know, computing is becoming more and more important in our society.
[00:31] There's now literally thousands of computers around the world, and they're being used
[00:37] from everything from business and accounting to scientific experiments and who knows what
[00:43] they're going to be used for.
[00:44] more and more computers, and coming down in price,
[00:47] coming down in size.
[00:49] Computer used to be the size of the entire hall,
[00:51] and now they've shrunk to really tiny proportions.
[00:54] So it's this time of really rapid change
[00:58] in the field of computing.
[00:59] So I thought it would be interesting to kind of look
[01:01] ahead a little bit to the future of programming
[01:04] and think about given what we know now,
[01:09] what programming might be like, say, 40 years from now.
[01:13] So what I'm going to talk about today,
[01:15] there's been some really interesting research that's been done just in the last ten years
[01:19] or so, and I think it's going to have a lot of implications for what programming might
[01:22] be like in the future.
[01:25] So there's four big ideas, four big topics that I want to talk about that have come
[01:31] out of recent research, but before I get to those four big ideas, I want to talk
[01:35] about the nature of adopting ideas in the first place.
[01:39] So basically what we notice is that technology changes quickly, people's minds change slowly.
[01:47] So it's easy to adopt new technologies, it can be hard to adopt new ways of thinking.
[01:53] So technology-wise, Gordon Moore, he has this company called Intel, and he observed
[02:03] about 10 years ago that computing capacity was increasing exponentially over time.
[02:07] And he kind of extrapolated this out to about now.
[02:10] And he's been right on target.
[02:12] And who knows how long this will keep it going.
[02:14] But it seems pretty reasonable.
[02:16] So the lesson to be drawn from this is that we can kind of
[02:20] take this for granted.
[02:21] We just kind of wait.
[02:22] Our computers get faster.
[02:23] They get more capable.
[02:24] We can just wait.
[02:24] And that's just going to happen.
[02:26] What won't just happen if we wait is people changing,
[02:30] people adopting new ideas.
[02:32] So as an example of that, I'm sure you all remember
[02:35] this guy, the old IBM 650, it's the, you know, IBM's first kind of general purpose mass produced
[02:42] computer.
[02:43] A lot of us cut our teeth programming on this guy.
[02:47] And in the beginning, right, we all programmed in absolute binary.
[02:52] When we coded, it was literally writing numeric codes for each instruction.
[02:56] And that was what we did, that was programming.
[02:58] And then after some years of that, Stan Poli came along and he invented this thing
[03:05] that he called an assembler.
[03:07] So that was this symbolic optimizing assembly program.
[03:11] This language where you could write in words.
[03:14] If you wanted the computer to add something, you'd write the word add.
[03:17] You could use symbolic variable names instead of hard coding memory addresses.
[03:21] Is this much more powerful way of thinking about programming.
[03:25] You're much more productive, mean much fewer errors.
[03:29] Assembly was shown to these guys, the guys coding in binary, and they just weren't
[03:34] interested at all.
[03:35] They just didn't get it.
[03:36] They didn't see any value in doing this stuff.
[03:40] So there can be a lot of resistance
[03:43] to new ways of working that require
[03:45] you to unlearn what you've already learned
[03:47] and think in new ways.
[03:49] And there can even be outright hostility.
[03:51] So Johnny von Neumann, the great scientist
[03:54] who invented the von Neumann computer architecture
[03:57] that we use and so many other things,
[03:59] he said, I don't see why anybody would need anything
[04:02] other than machine code.
[04:03] And he, one time, so he had a bunch of students
[04:07] and students were all kind of coding along in binary.
[04:10] And one time, one of his students took a little time out
[04:12] to write his own little assembler
[04:13] so he could write an assembly.
[04:15] And von Neumann was furious at him.
[04:17] Furious that he would waste precious machine time
[04:20] doing the assembly.
[04:22] That was clerical work.
[04:23] That was supposed to be for people, right?
[04:26] And so we saw the same story happen
[04:29] just a little bit later when John Backus and friends
[04:32] came up with this idea that they called Fortran,
[04:35] this so-called high-level language
[04:37] where you could write out your formulas
[04:39] as if you're writing mathematical notation,
[04:41] you could write out loops,
[04:43] and this was shown to the assembly of programmers,
[04:45] and once again, they just weren't interested.
[04:47] They didn't see any value in that.
[04:48] They just didn't get it.
[04:50] So I want you to keep this in mind
[04:54] as I talk about the four big ideas
[04:55] that I'm gonna talk about today,
[04:57] that it's easy to think that technology
[05:01] is always getting better because of Moore's Law,
[05:02] because the computer's always getting more capable.
[05:05] But ideas that require people to unlearn what they've learned
[05:08] and think in new ways, there's often
[05:10] an enormous amount of resistance.
[05:13] People over here, they think they know what they're doing,
[05:15] they think they know what programming is.
[05:16] This is programming, that's not programming.
[05:19] And so there's going to be a lot of resistance
[05:20] to adopting new ideas.
[05:26] The four ideas I want to talk about today,
[05:28] this is all coming out of very recent research.
[05:31] The first one is today we write our programs in code.
[05:35] We write basically a list of instructions for the computer to do.
[05:37] There's been some really interesting research on direct manipulation of data where you directly
[05:44] manipulate the data structures and that implicitly builds up a program for the computer
[05:48] to follow.
[05:49] Second thing I want to talk about, today we write procedures basically.
[05:52] Here's a procedure for the computer to do.
[05:55] Interesting research on programming using goals, telling the computer what you want,
[06:00] not how to do it.
[06:01] And the computer itself kind of fears not how to do it.
[06:04] Number three, today we program using lines of text and text files.
[06:11] People are doing something really remarkable, just like in the last five or ten years.
[06:13] They're hooking video displays up to computers.
[06:17] And when you do that, everything changes and you can start thinking about spatial
[06:20] representations of information.
[06:22] And the fourth thing is we program in a sequential programming model.
[06:26] Basically, here's a bunch of instructions, the computer does them one after the other,
[06:30] but hardware's changing.
[06:31] Soon we're going to see massively parallel hardware, and we're going to need a sound
[06:35] parallel program model to program on that hardware.
[06:40] So the first thing I'm going to talk about is that direct manipulation of data.
[06:46] And I'm going to show this project that Ivan Sutherland did, this was a PhD thesis
[06:51] about 10 years ago, the system called Sketchpad.
[06:55] And Sketchpad was a system that allowed you to draw pictures on a video display.
[07:00] So he took his light pen and put it on the screen.
[07:03] So he drew that line, drew that line, drew some more lines, drew this little top.
[07:09] He's trying to draw a rivet here.
[07:12] And he's drawing really sloppily, it's kind of tilted off to the side, it's kind of
[07:15] misshapen.
[07:17] So what he does is he then, he holds down a switch and indicates a couple of these
[07:24] lines to the computer system, indicating that he wants these lines to be mutually
[07:28] perpendicular.
[07:30] So the system runs an iterative solver, kind of wiggles the lines around, and figures out
[07:35] how to turn them into something that's mutually particular, how to turn them into a rectangle.
[07:41] So basically he, the system doesn't know anything about rectangles.
[07:47] He was able to get it to draw a rectangle by directly applying a set of constraints.
[07:53] And what makes this a program as opposed to just a picture is that these constraints
[07:57] are dynamically maintained.
[07:58] So he's got his rivet that he drew, and he resizes this corner of it and kind of resizes
[08:04] some of the things.
[08:05] The solver kicks back in, turns it back into a perfect rectangle.
[08:09] So essentially, he's created a program that draws a rectangle, but he didn't do it by
[08:14] writing code.
[08:15] He did it by directly manipulating the data and directly applying a set of constraints
[08:19] to them.
[08:21] And so this is kind of a simple example, and then he went off and did fancier things
[08:24] like here's a bridge simulation.
[08:28] So it actually simulates the physics of a bridge.
[08:30] He drew this by hand.
[08:32] The numbers here represent the tension
[08:34] in those particular spans of the bridge.
[08:38] And he can vary the weight, the load that's
[08:40] hanging off in the center of the bridge,
[08:42] and it kind of deforms.
[08:43] And the Sketchpad system doesn't know anything
[08:47] about bridges.
[08:48] He created this bridge simulation program
[08:50] by directly drawing it and by directly applying
[08:53] a certain set of very general constraints.
[08:57] So I definitely see this as something
[09:01] that's going to be really important in 34 years from now.
[09:04] I can imagine programming by directly manipulating
[09:07] j structures and letting that build up the code,
[09:11] but especially for things that are
[09:13] visual or physical like this.
[09:14] So say in a few decades, we get some sort of document
[09:18] format on some sort of web of computers, I guess.
[09:22] I'm sure we're going to be creating all those documents
[09:25] by direct manipulation.
[09:26] There won't be any markup languages or style sheet
[09:30] languages, right?
[09:31] That would make no sense.
[09:32] Ivan Sutherland showed us how to do it back here in 1962.
[09:36] So it's all going to be direct manipulation in the future,
[09:38] and that's going to be fantastic.
[09:41] So the second thing I wanted to talk about
[09:44] is programming using goals.
[09:48] So we saw a little bit of this with Sketchpad's
[09:52] constraint system.
[09:54] So Ivan Sutherland wanted to draw a rectangle.
[09:57] He didn't write a procedure to draw
[09:59] each side of the rectangle, he applied a set of constraints, and the system itself kind
[10:05] of figured out how to draw that rectangle. So he kind of said what he wanted, I want
[10:09] things to be mutually perpendicular. He didn't say how to do it. The solvers figured
[10:13] out how to do it. So another great example of that, that just came up a few years
[10:18] ago, Carl Hewitt is doing a system called Planner, which is really great. It actually
[10:23] goes in both directions. So it can reason forward procedurally. It can reason backwards
[10:28] from goals.
[10:29] So if you tell Planner that apples are red,
[10:32] then if you give it an apple, it knows, aha, it's red.
[10:35] But you can also say, I want something red.
[10:38] And it'll say, oh, let's try an apple.
[10:40] So you can express your program in terms of the goals,
[10:43] the results that you want from the program.
[10:45] But you can also provide procedural strategies
[10:48] for meeting certain types of subgoals.
[10:50] Really interesting way of thinking about programming.
[10:53] And this led to another system a few years later
[10:57] called prologue, which just kept the backwards part planner.
[11:00] So in prologue, you can express your program as goals.
[11:03] And the system itself uses search or whatever
[11:05] to try to figure out how to meet those goals.
[11:08] So this is leading to a genre of programming
[11:10] that's called logic programming.
[11:12] But that's not really the important part here.
[11:15] What's important is expressing your program
[11:17] as what you want it to do, not a set of instructions
[11:21] on how to do it, letting the computer itself figure out
[11:23] how to do it.
[11:24] Another example of that same sort of concept
[11:28] is pattern matching.
[11:29] So I'm sure you all remember Snowball.
[11:33] It's the text manipulation language.
[11:35] If you have a bunch of text you want to shoot through,
[11:37] you throw a Snowball script or program at it.
[11:40] And Snowball has built-in features for pattern matching.
[11:44] So you could express patterns that you
[11:46] want to match against the text.
[11:48] A little bit later, Ken Thompson,
[11:50] So for Bell Labs working on this system, they call it Unix.
[11:55] I know right, Unix.
[11:56] But he adopted Cleen's notion of regular expressions to do
[12:01] pattern matching on text.
[12:03] So when you have pattern matching, if you want to
[12:06] digest a big chunk of text, you don't go and write a
[12:09] parser that kind of goes procedurally through it.
[12:11] You provide a pattern, this kind of template.
[12:14] This is the sort of thing I'm looking for.
[12:15] And the system itself figures out how to match the text
[12:19] against that pattern.
[12:21] So all of these examples, sketch pads, constraints,
[12:27] planner, prologue, pattern matching, again,
[12:30] they're all examples of giving the computer high level
[12:33] goals, saying here's the sort of thing I'm looking for,
[12:35] letting the computer itself figure out how to do it.
[12:38] And we're seeing a little bit of that sort of thing
[12:40] in optimizing compilers, but I think
[12:41] it's going to be really prevalent in a few decades
[12:44] from now.
[12:45] And the reason that this is going
[12:47] to be so important, this goal directed stuff,
[12:49] has to do with this idea that Licklider is kicking around.
[12:56] So as you all know, Licklider is heading up ARPA,
[13:00] Government Funding Agency,
[13:01] and he's been pushing this idea
[13:03] of a global network of computers,
[13:06] just taking all the computers in the world
[13:08] and hooking them up to each other.
[13:09] And he calls it the Intergalactic Computer Network,
[13:14] because he knows that engineers always deliver the minimum,
[13:16] so if he asks for a network that spans the galaxy,
[13:18] He hopes to at least get one that spans the world.
[13:21] And people are calling this the ARPAnet now.
[13:25] It's turning into some sort of internet.
[13:29] I don't know, it's kind of a cute idea.
[13:31] Might work.
[13:33] And when you have this kind of global network of
[13:36] computers, you run into what Lookalighter calls the
[13:39] communicating with aliens problem.
[13:42] So he put it here, the problem is essentially the one
[13:44] discussed by science fiction writers.
[13:46] How do you get communication started among totally
[13:48] uncorrelated, sapient beings.
[13:52] And I'll explain what he means by that.
[13:57] So say you've got this network of computers,
[14:00] and you've got some program out here
[14:01] that was written by somebody at some time in some language
[14:04] that speaks some protocol.
[14:06] You've got another program over here
[14:08] written by somebody else some other time,
[14:09] speaks a totally different language,
[14:11] written in a totally different language.
[14:13] These two programs know nothing about each other.
[14:16] But at some point, this program
[14:19] will figure out that there's a service
[14:20] it needs from that program, that they have to talk to each other.
[14:24] So you've got these two programs, don't know anything
[14:27] about each other, written in totally different times,
[14:29] and now they need to be able to communicate.
[14:32] So how are they going to do that?
[14:34] Well, there's only one real answer
[14:37] to that that scales that's actually going to work,
[14:39] which is they have to figure out
[14:41] how to talk to each other, right?
[14:43] They need to negotiate with each other.
[14:45] They have to probe each other.
[14:46] They have to dynamically figure out a common language
[14:50] so they can exchange information and fulfill the goals
[14:54] that the human programmer gave to them.
[14:56] So that's why this goal-directed stuff is going
[14:58] to be so important when we have this internet,
[15:00] is because you can't write procedures,
[15:03] because we won't know the procedures for talking
[15:05] to these remote programs.
[15:07] These programs themselves have to figure out procedures
[15:09] for talking to each other and fulfill higher level goals.
[15:13] So if we have this worldwide network,
[15:16] I think that this is the only model that's going to scale.
[15:20] What won't work, what would be a total disaster,
[15:23] is I'm going to make up a term here, API.
[15:26] This notion that you have a human programmer that
[15:30] writes against a fixed interface that's
[15:32] exposed by some remote program.
[15:35] First of all, this requires the programs
[15:37] to already know about each other.
[15:40] And when you're writing this program in this one's language,
[15:44] now they're tied together.
[15:46] So the first program can't go out and hunt
[15:47] and find other programs that implement the same service.
[15:50] They're tied together.
[15:51] If this one's language changes, it breaks this one.
[15:55] It's really brittle.
[15:56] It doesn't scale.
[15:58] And worst of all, it's basically a machine code problem.
[16:03] You have a human doing low-level details that
[16:06] should be taken care of by the machine.
[16:08] So I'm pretty confident this is never going to happen.
[16:11] We're not going to have APIs in the future.
[16:13] What we are going to have are programs
[16:17] that know how to figure out how to talk to each other.
[16:20] And that's going to require programming and goals.
[16:29] The third big idea that I want to talk about
[16:32] is spatial representation of information.
[16:34] So today, our programs are basically
[16:37] lots of lines of text, big file full of lines of text.
[16:40] And that makes sense when your program is
[16:44] on a stack of punch cards, or it's
[16:46] a paper tape or a magnetic tape.
[16:48] This very linear media makes sense
[16:50] to have your program in this kind of linear form.
[16:53] If you're using a teletype, then a teletype
[16:55] is made for spitting out lines of text.
[16:57] That's what it does.
[16:58] So of course your programs are going to be in lines of text.
[17:00] But as I mentioned, people are doing something really wild
[17:04] and crazy right now, which is hooking video displays up
[17:07] to computers.
[17:08] And when you have a video display hooked up
[17:09] to a computer, you can start thinking of your computer
[17:12] as kind of this very dynamic sheet of paper
[17:14] where you can represent things spatially.
[17:17] So Doug Engelbart over at SRI has a system
[17:25] that he calls Online System, NLS.
[17:29] He gave a big demo five years ago.
[17:31] You might have seen it.
[17:32] And there's a lot of really remarkable things
[17:34] about the system.
[17:35] One of the most remarkable is this notion
[17:37] of displaying information over a screen, over a video screen.
[17:41] So he has this device called a mouse where
[17:47] you kind of roll it around the table
[17:49] and it's kind of hard to explain.
[17:50] But you can use this to point
[17:52] to different parts of the screen
[17:53] and indicate that you want more information about something
[17:56] that you're pointing to.
[17:58] And it also has this notion of different views of information.
[18:02] So you can see here, it has some data in a list.
[18:06] And they can flip that over and look at that same data
[18:08] as this kind of two-dimensional diagram.
[18:11] So really starting to think about,
[18:12] how can we represent dynamic information spatially?
[18:18] Another great system, kind of about the same time
[18:21] coming out of the RAND Corporation, was called GRAIL.
[18:24] And this is a system for programming using flowcharts
[18:28] on a video display.
[18:30] And the input device here is a stylus on a tablet.
[18:34] And you can drop these flow charts.
[18:38] And let me show you how that works.
[18:42] The programmer is drawing this box
[18:44] and just kind of totally free handing it.
[18:46] And he draws a box.
[18:47] And the system recognizes that as a box
[18:50] and turns it into a flow chart box.
[18:52] So it assigns semantic meaning to these drawings
[18:55] that he's doing.
[18:57] He wants to give it a label.
[18:58] So he just starts writing letters.
[19:01] The system recognizes his handwriting, it's 1968.
[19:06] System recognizes his handwriting, turns it into text.
[19:10] Here he connects up this box to that one with a line
[19:14] and so on, so it's all very direct manipulation.
[19:18] If he wants to get rid of this line,
[19:19] he just kind of scribbles it out and goes away.
[19:21] And so really thinking about what programming means
[19:24] when you have a video display,
[19:26] when you can express things in two dimensions.
[19:29] But when I'm talking about spatial representation
[19:31] of information, I'm not just talking about things
[19:32] like flow charts.
[19:33] So Xerox has a little research center in Palo Alto.
[19:39] There's some kids over there working on something
[19:41] that they call Smalltalk.
[19:42] And in Smalltalk, the source code is expressed in text,
[19:47] but there's no big, long text file
[19:51] with a whole bunch of code in it.
[19:54] It's organized in a spatial fashion.
[19:55] So here's what they call a browser.
[19:57] So in this list here, here's all the collections of classes,
[20:01] here's all the classes in that collection,
[20:02] here's all the protocols in that class,
[20:04] here's all the methods in that protocol,
[20:06] and here's the source code for that particular method.
[20:09] So the method definitions are text,
[20:12] but they're not one huge line of text,
[20:15] they're organized spatially,
[20:17] so you can get around the system very quickly
[20:19] and see what's going on.
[20:20] So between Engelbart's NLS, Grail, Smalltalk,
[20:26] these very different ways
[20:27] of representing information spatially.
[20:28] So I'm totally confident that in 40 years,
[20:30] we won't be writing code in text files, right?
[20:35] We've been shown the way.
[20:37] And as a side note, all these systems I just showed you,
[20:46] Engelbart system, Grail, Smalltalk,
[20:49] this thing that's going on at University of Illinois
[20:51] called Play-Doh, also a really interesting system.
[20:53] These are part of this new wave of interactive computing
[20:58] where you sit down at the computer
[20:59] and you're actually interacting with the computer in real time.
[21:03] And these guys know that they're trying
[21:05] to prove out this new concept.
[21:07] And so they've designed the system from the very bottom
[21:10] to have an immediate response.
[21:11] The user interface is always immediately responsive.
[21:15] You interact with anything, you immediately get a response.
[21:18] So it's kind of simulating a physical object.
[21:21] And so if interactive computing takes off,
[21:25] and I think it will, then I think
[21:28] is pretty obvious that in 40 years, our user interfaces, if you interact with them, you'll
[21:32] never experience any kind of delay or lag, right? Because these guys proved how important
[21:40] is to have an immediate response of UI and they were doing this in the, in the 60s,
[21:45] so as our computers get a million times faster, obviously there's no reason to
[21:48] have any kind of delay or lag in the operating system, in the, in the user interface.
[21:52] So that's going to be really exciting. The fourth thing that I want to talk about
[22:00] is parallel programming.
[22:04] So today, our programs are basically
[22:07] a sequence of instructions.
[22:08] Computer, do this, then do that, then do that,
[22:10] then do that.
[22:11] And one of the reasons that we program in the sequential model
[22:17] has to do with the hardware.
[22:21] So we've been using this computer architecture
[22:24] called the von Neumann computer architecture,
[22:26] where you have a processor and then it's
[22:29] hooked up to a big memory and it's fetching words from memory.
[22:32] And so the sequential programming model
[22:36] makes sense when you just have one processor.
[22:37] A processor can only do one thing at a time.
[22:39] You give us a list of things for the processor to do,
[22:41] and it just kind of does each one of those.
[22:45] One characteristic of the von Neumann architecture,
[22:49] though, is that most of this memory
[22:52] is idle most of the time.
[22:54] So you've got this little processor over here,
[22:56] and it's kind of processing as fast as it can.
[22:58] But only one word of memory is ever being accessed.
[23:01] the rest of the memory is just kind of sitting there waiting.
[23:04] And that works when your processor is made out
[23:09] of vacuum tubes or relays.
[23:11] And it's kind of big and expensive.
[23:13] And your memory is made out of core or a rotating drum.
[23:16] It's also big and expensive and different.
[23:18] Then you can kind of get away with that.
[23:20] But we're starting to see an incredible invention coming
[23:25] into the field of computing right now, which is,
[23:28] I think, going to change everything.
[23:30] And that is the integrated circuit, semiconductor
[23:33] integrated circuit.
[23:35] So this is a thing that a company called Intel made.
[23:39] It's called a microprocessor.
[23:41] And it's an entire processor on a single piece of silicon.
[23:46] So the entire processor is just made out of transistors.
[23:48] And a transistor is just a little picture
[23:50] that you etch into silicon.
[23:52] And the entire circuit is just one big complicated picture
[23:54] that you etch into the silicon.
[23:56] So our processors are just made out
[23:58] of transistors and silicon.
[24:00] Our memories, as well, are also going
[24:03] to be made of transistors on silicon.
[24:06] It's all the same stuff.
[24:08] So when you look at the von Neumann architecture
[24:10] from that perspective, you've got these transistors
[24:12] over here that are working really hard,
[24:14] they're processing things.
[24:15] And you've got this huge array of transistors over here,
[24:18] most of which are just kind of sitting, waiting.
[24:21] They're not processing.
[24:23] They're not doing anything.
[24:25] And so if you want to put those transistors to work,
[24:30] If you actually want to maximize the amount of processing
[24:34] that you're going to get out of a piece of silicon,
[24:37] you need to start looking at things that are more like this.
[24:44] So what computers want to be on silicon
[24:47] is they want to be lots of little computers,
[24:49] like a huge array of tiny little computers
[24:51] with their own processor, their own little state,
[24:53] doing their own thing, communicating with each other.
[24:55] That's how you maximize the amount of compute
[24:58] per area of silicon and the scales.
[25:01] So when the transition gets smaller,
[25:03] when the silicon diary gets bigger,
[25:05] you have all this extra space,
[25:07] you just fill it up with more processors, right?
[25:09] Done, really easy.
[25:11] So this is the kind of architecture
[25:14] that we're gonna be programming on in the future,
[25:17] unless Intel somehow gets a stranglehold
[25:21] on the market and pushes this architecture forward
[25:23] for 30 years, but that's not gonna happen.
[25:25] We're gonna be programming on these things.
[25:28] And when you have this hardware,
[25:29] you have to start thinking about,
[25:31] how do we program on that?
[25:33] What's our programming model?
[25:34] for this sort of hardware.
[25:36] And the way that we do programming today
[25:40] is with threads and locks, right?
[25:42] You have a few sequential threads of control
[25:45] and you kind of pretend that they're going in parallel
[25:47] by multiplexing them onto a processor
[25:48] and they try to lock each other out
[25:50] from shared resources.
[25:52] And like this is never gonna work, right?
[25:56] This does not scale.
[25:57] You can't reason about hundreds of threads
[25:59] all banging on the same shared memory at the same time.
[26:01] Threads and locks are, they're kind of a dead end, right?
[26:06] So I think if in 40 years we're still using threads and locks, we should just like pack up and
[26:09] go home because we've clearly failed as an engineering field.
[26:13] So if it's not threads and locks, then what's going to work?
[26:18] And Carl Hewitt, that's the same Carl Hewitt that did Planner, came up with
[26:22] this idea that he called the actor model.
[26:25] So the actor model is a model of computation that's inspired by physics.
[26:29] So in physics, you've got all these particles, and all the particles are just independently
[26:33] doing their own thing, and they have their own little state, and they interact with the
[26:38] ones that are around them.
[26:40] And Carl Hewitt was thinking of computer processes in the same way.
[26:43] You've got a whole bunch of processes, and they're all kind of asynchronously doing
[26:46] their own little thing.
[26:47] They have their own little state, and they're sending messages to each other.
[26:51] So really interesting, really new and exciting way of thinking about programming.
[26:55] So it's kind of heating up right now.
[26:57] Gilles Kahn over in France has some ideas.
[27:00] I think Tony Hoare is getting into it with something
[27:02] he's going to be calling Communicating Sea Control
[27:04] Processes.
[27:05] And maybe even Raman Miller is going to join the party.
[27:08] So really exciting stuff happening here.
[27:12] Now, for this talk, the details
[27:14] of these particular models don't really matter.
[27:17] I do think it would be kind of cool
[27:19] if the actor model was picked up by the Swedish phone
[27:22] company or something.
[27:23] That would be kind of weird.
[27:25] But what matters here is we are going to have massively parallel hardware.
[27:32] We need a sound parallel programming model that fits the hardware.
[27:37] And something like this is going to be what we're going to be using.
[27:48] So those are the four things I wanted to talk about.
[27:53] Direct manipulation of data, something like a sketch pad where you're drawing pictures,
[27:57] dynamically adding constraints to those pictures, directly manipulating the data structures instead
[28:01] of writing instructions for the program.
[28:05] Using goals and constraints, things like sketch pads, constraints, planner and prologue,
[28:12] regular expressions, other types of pattern matching, where you're telling the computer
[28:16] what you want to do and the computer itself has solvers that figure out how to do that.
[28:21] Spatial representation of information, we're not going to have text files anymore.
[28:26] We're going to be representing information spatially because we have video displays.
[28:30] And fundamentally parallel ways of thinking, parallel hardware, parallel program models,
[28:36] No more threads and locks, no more sequential thinking.
[28:39] So those are the four things I wanted to talk about.
[28:44] And I've tried to make some predictions about the future, and you can't really predict
[28:49] the future, right?
[28:50] So these are some good ideas.
[28:53] I don't know what's going to happen to them.
[28:54] Ideas kind of split and merge and go in and out of fashion.
[28:57] So anything could happen.
[29:00] But I do think that it would be kind of a shame if in 40 years we're still coding
[29:07] in procedures, in text files, in sequential programming model,
[29:13] I think that would suggest we didn't learn anything
[29:16] from this really fertile period in computer science.
[29:19] So that would kind of be a tragedy.
[29:22] But even more of a tragedy than these ideas not being
[29:26] used would be if these ideas were forgotten, right?
[29:30] If anybody were ever to be shown this stuff
[29:32] and actually be surprised by it, right?
[29:36] But even that's not the biggest tragedy.
[29:38] That's not the real tragedy.
[29:40] The real tragedy would be if people forgot
[29:43] that you could have new ideas about programming
[29:44] models in the first place.
[29:48] So let me explain what I mean by that.
[29:52] Here's what I think the worst case scenario would be,
[29:55] is if the next generation of programmers
[29:58] grows up never being exposed to these ideas.
[30:01] The next generation of programmers
[30:03] grows up only being shown one way of thinking
[30:06] about programming.
[30:07] So they kind of work on that way of programming.
[30:09] They flesh out all the details.
[30:11] They kind of solve that particular model of programming.
[30:15] They figure it all out.
[30:17] And then they teach that to the next generation.
[30:20] So that second generation then grows up
[30:22] thinking, oh, it's all been figured out.
[30:25] We know what programming is.
[30:26] We know what we're doing.
[30:29] They grow up with dogma.
[30:31] And once you grow up with dogma,
[30:33] it's really hard to break out of it.
[30:38] Do you know the reason why all these ideas
[30:40] and so many other good ideas came about
[30:42] in this particular time period, in the 60s, early 70s.
[30:45] Why did it all happen then?
[30:48] It's because technology, it was late enough
[30:53] that technology kind of got to the point
[30:54] where you could actually kind of do things with computers,
[30:57] but it was still early enough
[30:58] that nobody knew what programming was.
[31:03] Nobody knew what programming was supposed to be,
[31:06] and they knew they didn't know,
[31:07] so they just like tried everything.
[31:08] Their minds were totally free,
[31:10] and they just like said,
[31:11] maybe we could program like this,
[31:12] Maybe we could program like that.
[31:13] They just tried anything they could think of.
[31:18] So the most dangerous thought that you
[31:26] can have as a creative person is
[31:28] to think that you know what you're doing.
[31:31] Because once you think you know what you're doing,
[31:34] you stop looking around for other ways of doing things.
[31:36] And you stop being able to see other ways of doing
[31:38] things.
[31:39] You become blind.
[31:40] You become like these guys over here,
[31:44] kind of coding along in binary.
[31:46] someone shows them assembly language,
[31:48] someone shows them Fortran,
[31:50] and they can't even see it.
[31:51] Just goes right over their head
[31:53] because they know what they're doing.
[31:55] They know what programming is.
[31:56] This is programming.
[31:57] That's not programming.
[31:58] And so they totally miss out
[32:00] on this much more powerful way of thinking.
[32:04] So the message of this talk,
[32:07] it's not really the stuff, right?
[32:10] The message of this talk is
[32:12] if you don't wanna be this guy,
[32:16] If you want to be open and receptive
[32:18] to new ways of thinking, to invent new ways of thinking,
[32:22] I think the first step is you have to say to yourself,
[32:25] I don't know what I'm doing.
[32:27] We as a field don't know what we're doing.
[32:31] I think you have to say,
[32:31] we don't know what programming is.
[32:34] We don't know what computing is.
[32:35] We don't even know what a computer is.
[32:37] And once you truly understand that,
[32:40] and once you truly believe that,
[32:43] then you're free, and you can think anything.
[32:47] Thank you.