The Future of Programming — Bret Victor
“Bret dresses up as a 1973 computer scientist giving a talk on what programming will look like in 40 years. He brilliantly exposes how our modern tools are trapped in local optimums.”
Executive Summary: Escaping the Local Minima of 1970s Textual Coding
Delivered at Dropbox DBX in 2013, Bret Victor’s “The Future of Programming” is a brilliant meta-parody presentation delivered entirely as if the speaker were living in the year 1973. Dressed in vintage 1970s attire with retro overhead projector slides, Victor looks forward from 1973 into the future of computing (the 2010s and 2020s), reviewing the radical programming paradigms being invented in the late 1960s and early 1970s: direct spatial programming, constraint-based systems (Ivan Sutherland's Sketchpad), message-passing concurrent actors (Alan Kay, Carl Hewitt), and goal-driven probabilistic logic systems (Prolog, Smalltalk). The devastating punchline of the talk is that almost none of these revolutionary computing concepts survived into modern software engineering. Instead, contemporary programming regressed and stagnated into a local minimum: typing sequential ASCII characters into flat text files (C, C++, Java, JavaScript, Python)—a paradigm fundamentally derived from 1950s punched cards and teletype printers.
Key Mental Models Derived from this Lecture:
- The 1973 Retro Lens: Stepping outside contemporary cultural assumptions by examining modern software tools from the vantage point of early computing pioneers.
- The 4 Dogmas of Contemporary Programming: Code as Text (forcing multidimensional concepts into 1D character streams), Sequential Execution, Manual Micro-State Mutation, and Passive Data.
- Constraint-Based Programming: Instead of writing imperative loops explaining how state changes step-by-step, specify invariant physical constraints and let the computer solve the transitions.
- Spatial & Visual Representations: Humans evolved millions of years of spatial and tactile reasoning; text-based code discards 90% of human sensory bandwidth.
- The Tragedy of the Local Optimum: Massive commercial entrenchment (operating systems, tooling, developer habits) traps an entire industry in an inferior technological baseline.
- Questioning Ambient Assumptions: Every modern software practice (git commits, text editors, terminal shells) is an artifact of historical accident rather than natural law.
Key Timestamps: The Future of Programming 1973 Retrospective
Introduction from 1973: Assessing 50 Years of Programming Evolution
Beyond Text: Graphical, Visual, and Spatial Programming Paradigms
Beyond Sequential Execution: Actor Models, Parallel Flows, and Concurrency
Beyond Step-by-Step Logic: Constraint Solvers and Goal-Directed Computation
The Tragedy of the 2010s: Why the Industry Standardized on 1950s Text Files
The Challenge to Developers: Daring to Build Post-Teletype Programming Media
Conceptual Formulations: The 4 Dogmas of Contemporary Programming
Information Bandwidth Inequality: Spatial Graphics vs 1D ASCII Streams
The human optic nerve transmits visual patterns to the cerebral cortex at approximately 10 million bits per second. Typing and reading 1D sequential characters utilizes less than 50 bits per second, squandering over 99.999% of human sensory processing capacity.
# Comparing 1D Sequential Code vs Multi-dimensional Constraint Graph # 1D Sequential Imperative (Dogmatic): x = 10 y = x * 2 z = y + 5 # If x changes, z does not update without rerun! # Multi-dimensional Reactive Constraint (Future): solver.add_constraint(lambda: y == x * 2) solver.add_constraint(lambda: z == y + 5) x.set(20) # y automatically becomes 40, z automatically becomes 45
Constraint Satisfaction Invariant Formulation
In imperative programming, the developer must manually orchestrate state transitions x_{t+1} = f(x_t). In constraint-based programming (pioneered by Sketchpad), the programmer specifies relationship invariants C(x) = 0, and relaxation algorithms solve the state.
# Sketchpad relaxation solver for geometric constraints
def relax_constraints(points, constraints, tolerance=1e-5):
while calculate_error(points, constraints) > tolerance:
for c in constraints:
c.apply_force(points) # Simulates physical relaxation to solve geometryThe Cultural Inertia Decay Function in Software Engineering
As the number of legacy programmers, operating systems, and commercial codebases N_legacy grows, the cultural inertia resisting paradigm shifts grows exponentially, locking the industry into the local minimum of text editors.
# Modeling paradigm lock-in: Once infrastructure standardizes, escape requires revolution
def adoption_probability(new_paradigm_gain, legacy_ecosystem_mass):
return new_paradigm_gain / (1.0 + math.exp(legacy_ecosystem_mass))Community Consensus: Hacker News Debates on Bret Victor’s DBX Talk
Why Did Text-Based Programming Defeat Visual Programming Languages?
“Text didn't win because it's better; text won because it was the lowest common denominator for cheap 1970s hardware.” — @smalltalk_veteran
Are AI Code Assistants Cementing Text or Freeing Us from It?
“Having AI generate 500 lines of boilerplate text is the ultimate admission that text-based coding was the wrong abstraction.” — @copilot_user
The 1973 Framing Device as Rhetorical Masterpiece
“Watching someone in 1973 predict our 2013 reality as a catastrophic failure of imagination is the most humbling talk any programmer can watch.” — @retro_computing_geek
Technical FAQ: Visual Programming, Constraints, Moore’s Law and Papert
In Simple Made Easy, what is the fundamental difference between Simple and Easy?
In the Simple Made Easy lecture by Rich Hickey, Simple is an objective design property (simplex: having a single role, unbraided), whereas Easy is subjective and relative to developer familiarity (facilis: near at hand).
What does the Simple Made Easy lecture mean by the verb “to complect”?
In Simple Made Easy, to complect means to braid, intertwine, or fold multiple distinct concerns together (from Latin complecti). Once concepts are complected, you cannot reason about or test one without dragging the other along.
Why does Simple Made Easy advocate for immutable values over mutable state?
Simple Made Easy proves that mutable state braids value and time together. Immutable values represent permanent historical facts that can be freely shared across concurrent threads without locks, cached indefinitely, and trivially reasoned about.
How does the Epochal Time Model in Simple Made Easy solve concurrency?
In Simple Made Easy, identity is an atomic reference pointing to an immutable value snapshot at time t. Updates apply a pure function to produce a new immutable value at t+1 and swap the reference atomically (e.g. CAS), allowing lock-free reads.
Why does Simple Made Easy recommend passing plain data maps instead of OOP classes?
In Simple Made Easy, plain associative maps represent information directly without braiding data representation with domain logic or class inheritance hierarchies, enabling universal composition.
What architectural constructs does Simple Made Easy recommend for decoupled systems?
Simple Made Easy recommends five foundational constructs: persistent immutable data structures, declarative data (like JSON or EDN), asynchronous queues to decouple space and time, pure functions, and runtime schemas.
