Bret Victor The Future of Programming

SUMMARY

Bret Victor, dressed as a 1970s IBM engineer, delivers a visionary talk at Dropbox's DBX conference, urging programmers to embrace radical innovations in computing from the 1960s-70s, predicting direct data manipulation, goal-based programming, spatial interfaces, and parallel models for the future.

STATEMENTS

Computing is rapidly advancing with thousands of computers worldwide, shrinking in size and cost, used for business, science, and more, signaling a transformative era.
Recent research from the last decade points to four major ideas reshaping programming: direct data manipulation, goal-oriented programming, spatial information representation, and parallel programming models.
Technology evolves quickly due to Moore's Law, exponentially increasing computing power, but human minds and adoption of new ideas change slowly, creating resistance.
Early programmers coded in binary, resisting assemblers like Stan Poley's, which allowed symbolic names and words, viewing them as unnecessary.
John von Neumann dismissed anything beyond machine code, even berating a student for creating an assembler, seeing it as wasteful clerical work.
Fortran, a high-level language by John Backus, enabled writing mathematical formulas and loops, but assembly programmers rejected it outright.
Resistance to new ideas stems from unlearning old ways, leading to hostility and blindness to better methods.
In direct manipulation, Ivan Sutherland's 1963 Sketchpad allowed drawing on video displays with a light pen, applying constraints to dynamically adjust shapes like rectangles or simulate bridges.
Sketchpad's constraints create programs implicitly by maintaining rules on data structures, without writing explicit code.
Future programming will involve direct data manipulation for visual or physical tasks, eliminating markup or stylesheet languages in document creation.
Goal-based programming, like Carl Hewitt's Planner, reasons forward and backward from goals, allowing expression of desired outcomes rather than procedures.
Prolog, derived from Planner, focuses on backward reasoning, using search to meet goals, exemplifying logic programming.
Pattern matching in SNOBOL and Unix's regular expressions lets users specify desired patterns, with the system handling the matching process.
Goal-directed approaches will be crucial for the ARPANET, enabling programs to negotiate communication dynamically, avoiding brittle APIs.
Spatial representation shifts from linear text files to dynamic video displays, as in Doug Engelbart's NLS with mouse-driven views and diagrams.
GRAIL enables programming via stylus-drawn flowcharts on tablets, recognizing shapes and handwriting for direct manipulation.
Smalltalk organizes code spatially in browsers, listing classes, protocols, and methods for quick navigation, not as monolithic text files.
Interactive systems like NLS, GRAIL, Smalltalk, and PLATO emphasize immediate responsiveness, simulating physical objects without lag.
Von Neumann architecture wastes memory potential, but integrated circuits like Intel's microprocessor enable massive parallelism with arrays of tiny processors.
Current threading and locking won't scale for parallel hardware; instead, models like Carl Hewitt's actor model treat processes as independent particles sending messages.

IDEAS

Programming could evolve from writing instructions to directly shaping data structures, where constraints automatically generate and maintain code-like behaviors.
Telling computers "what" to achieve, rather than "how," empowers systems to solve problems autonomously, mirroring human goal-setting in complex environments.
Video displays transform programming from linear text to multidimensional spatial layouts, unlocking intuitive navigation and visualization of code relationships.
Massive parallelism in future hardware demands rethinking computation as independent actors communicating asynchronously, inspired by physical particles.
Historical resistance to innovations like assemblers and Fortran reveals how overconfidence in existing methods stifles creativity and productivity.
The "communicating with aliens" problem in networks like ARPANET necessitates self-negotiating programs, making fixed APIs obsolete and unscalable.
Early interactive systems proved lag-free interfaces are essential, predicting zero-delay user experiences as hardware advances.
Fertile periods in computing arise when pioneers admit ignorance, freely experimenting without dogma constraining imagination.
Integrated circuits blur lines between processors and memory, optimizing silicon by filling it with countless small, active computing units.
Spatial tools like flowcharts and browsers make code exploration feel like browsing a dynamic map, accelerating understanding and debugging.
Goal-directed programming scales for interconnected systems, allowing alien programs to dynamically discover and adapt to each other.
Forgetting past radical ideas risks trapping future generations in outdated paradigms, perpetuating sequential thinking on parallel hardware.
Embracing uncertainty about "what a computer is" liberates thinkers to redefine programming entirely, fostering breakthroughs.

INSIGHTS

True innovation in programming demands humility; believing you "know" the field blinds you to superior alternatives, as seen in early dismissals of high-level languages.
Direct manipulation of data democratizes creation, turning visual intuition into executable programs without syntactic barriers, ideal for spatial domains like design.
Goal-based paradigms shift burden from human procedural detail to machine intelligence, essential for scalable, adaptive systems in global networks.
Spatial interfaces evolve computing from typewriter-like linearity to canvas-like dynamism, revealing hidden code structures that text conceals.
Parallel models like actors align software with hardware's natural multiplicity, maximizing efficiency by mimicking decentralized natural systems.
Resistance to new ideas isn't technological but psychological; unlearning dogma requires admitting collective ignorance to spark exploration.
Future networks will thrive on autonomous negotiation, rendering rigid interfaces like APIs relics, as programs must evolve communication organically.
Interactive immediacy isn't a luxury but a foundational principle; lag erodes trust, so advancing hardware must prioritize fluid human-computer symbiosis.
The tragedy of forgotten ideas lies in lost potential; without exposure to historical experimentation, programmers risk dogmatic stagnation.
Silicon's uniformity favors distributed processing over centralized bottlenecks, urging a paradigm where every transistor contributes actively.

QUOTES

"The most dangerous thought that you can have as a creative person is to think that you know what you're doing."
"Because once you think you know what you're doing you stop looking around for other ways of doing things and you stop being able to see other ways of doing things. You become blind."
"We don't know what programming is. We don't know what computing is. We don't even know what a computer is."
"And once you truly understand that, and once you truly believe that, then you're free, and you can think anything."
"The promise is essentially the one discussed by science fiction writers: how do you get communication started among totally uncorrelated sapient beings."
"If in forty years we're still coding in procedures in text files in a sequential programming model I think that would suggest we didn't learn anything from this really fertile period in computer science."
"The real tragedy would be if people forgot that you could have new ideas about programming models in the first place."

HABITS

Maintain an open mindset by regularly questioning foundational assumptions about your field to avoid dogmatic blindness.
Experiment freely with unconventional approaches, drawing from historical innovations without preconceived notions of "proper" methods.
Prioritize immediate responsiveness in interactive tools, simulating physical objects to build intuitive user experiences.
Expose yourself to diverse representations of information, shifting from linear text to spatial visualizations for deeper insights.
Admit ignorance collectively as a team or field to foster creative freedom and collaborative idea generation.
Draw and manipulate prototypes directly, using constraints to dynamically refine designs rather than rigid instructions.

FACTS

Gordon Moore's 1965 observation predicted exponential growth in computing capacity, holding true for decades via transistor density doubling roughly every two years.
Ivan Sutherland's 1963 Sketchpad introduced the first graphical user interface with a light pen, enabling constraint-based drawing on a video display.
Doug Engelbart's 1968 "Mother of All Demos" showcased the mouse, hypertext, and collaborative tools in NLS, revolutionizing human-computer interaction.
Carl Hewitt's Planner system in the late 1960s pioneered bidirectional reasoning for AI, influencing logic programming languages like Prolog.
J.C.R. Licklider's 1960s vision for ARPANET laid groundwork for the internet, addressing challenges in interconnecting diverse computer systems.
Integrated circuits, like Intel's 1971 microprocessor, miniaturized processors onto silicon chips, paving the way for personal computing revolutions.

REFERENCES

Ivan Sutherland's Sketchpad (1963 PhD thesis).
Stan Poley's Symbolic Optimizing Assembly Program (assembler).
John Backus's Fortran (high-level language).
Carl Hewitt's Planner system.
Prolog (logic programming language from Planner).
SNOBOL (text manipulation language with pattern matching).
Ken Thompson's Unix and regular expressions.
J.C.R. Licklider's "Intergalactic Computer Network" and ARPANET.
Doug Engelbart's NLS (oN-Line System) and mouse.
RAND Corporation's GRAIL (flowchart programming system).
Xerox PARC's Smalltalk (object-oriented language with spatial browser).
University of Illinois' PLATO (interactive computing system).
Carl Hewitt's Actor Model.
Gilles Kahn's work on parallel programming.
Tony Hoare's Communicating Sequential Processes.
Robin Milner's contributions to concurrency.

HOW TO APPLY

Start by sketching data structures visually on a digital canvas, applying simple constraints like alignment or proportionality to see dynamic adjustments emerge.
Define programming tasks as high-level goals, such as "match this pattern in text," and let tools like regular expressions or solvers handle the implementation details.
Organize code in spatial browsers, grouping related elements like classes and methods into navigable hierarchies to accelerate exploration and editing.
Simulate parallel processes as independent actors sending messages, prototyping small networks to test asynchronous interactions without shared state locks.
Regularly review historical computing experiments, like Sketchpad or NLS, to challenge your current paradigms and inspire novel adaptations in modern tools.

ONE-SENTENCE TAKEAWAY

Embrace ignorance of programming's essence to freely innovate beyond text-based, sequential dogma toward dynamic, goal-driven futures.

RECOMMENDATIONS

Abandon fixed APIs for self-negotiating programs that dynamically adapt in networks, ensuring scalability without human intervention.
Integrate video displays into all coding environments to enable spatial code representations, replacing linear text files entirely.
Adopt actor-like models for parallelism, focusing on message-passing over threads to harness future hardware efficiently.
Teach computing history emphasizing experimental eras to prevent dogmatic thinking in new generations of programmers.
Prioritize lag-free interfaces in every tool, leveraging hardware advances to make interactions feel physically immediate.
Experiment with direct manipulation in daily workflows, using constraints to build and refine prototypes intuitively.
Shift to goal-oriented declarations in code, allowing compilers or AI to infer procedures for complex problem-solving.
Foster field-wide humility by hosting discussions admitting "we don't know what computing is" to spark radical ideas.

MEMO

In a dimly lit hall at Dropbox's DBX conference on July 9, 2013, Bret Victor stepped onto the stage not as a modern tech visionary but as a time traveler from 1973. Dressed in the starched uniform of an IBM systems engineer, complete with pocket protector and overhead projector, he evoked an era when computing was raw, experimental, and unbound by convention. Victor's talk, "The Future of Programming," wasn't a prediction rooted in silicon valleys of the future but a passionate revival of ideas from the 1960s and early '70s—a golden age of unfettered innovation before dogma calcified the field. "The most dangerous thought you can have as a creative person," he warned, projecting faded slides, "is to think you know what you're doing." This blindness, he argued, had already doomed early pioneers to reject breakthroughs like assemblers and Fortran, and it threatens to stall progress today.

Victor's core thesis hinged on four transformative ideas emerging from that fertile period, each challenging the sequential, text-based programming model still dominant. First, he showcased Ivan Sutherland's 1963 Sketchpad, a PhD project that hooked a light pen to a video display, allowing users to draw sloppy lines and then impose constraints—like mutual perpendicularity—that an iterative solver refined into perfect rectangles or even physics-simulating bridges. No code was written; the program emerged implicitly from manipulated data. Victor envisioned a future where documents and interfaces are crafted this way, rendering markup languages obsolete. "Sutherland showed us how in 1962," he said. "It's going to be fantastic."

Shifting to goal-directed programming, Victor highlighted Carl Hewitt's Planner and its offspring Prolog, where coders specify desired outcomes—red apples or pattern matches—letting the system reason backward or forward to achieve them. Drawing from SNOBOL's pattern matching and Unix's regular expressions, he explained how this "tell the computer what you want" paradigm scales for J.C.R. Licklider's nascent ARPANET. In a world of "communicating with aliens"—unfamiliar programs negotiating protocols—fixed APIs would brittlely fail. Instead, autonomous systems must probe and adapt, fulfilling human-set goals without predefined handshakes. This, Victor predicted, is the only model for a global internet.

The third pillar was spatial representation, born from hooking video displays to computers. Victor demoed Doug Engelbart's 1968 NLS with its mouse-driven views, flipping lists into diagrams, and RAND's GRAIL, where styluses sketched recognized flowcharts. Even Xerox PARC's Smalltalk organized code in browsable hierarchies, not endless text scrolls. These tools, alongside PLATO's interactive ethos, proved immediacy's power—no lag, just fluid response. As hardware explodes via Moore's Law and integrated circuits, Victor foresaw text files vanishing, replaced by dynamic, multidimensional canvases that make code as navigable as a city map.

Finally, parallelism loomed as hardware's inevitable shift. Von Neumann's single-processor bottleneck wastes silicon potential; microprocessors like Intel's herald arrays of tiny, independent units. Threads and locks won't scale—Victor called them a "dead end." Enter Hewitt's actor model: processes as particles, asynchronously messaging without shared memory. Echoing emerging works by Gilles Kahn and Tony Hoare, he urged a physics-inspired rethink. Yet the true peril, Victor concluded, isn't unadopted ideas but forgotten ones. If future programmers grow dogmatic, blind to experimentation's spirit, computing stagnates. "We don't know what a computer is," he implored. "Once you believe that, you're free to think anything." In reclaiming this humility, Victor didn't just forecast 2013's future—he ignited a call to redefine it.