Dan Ingalls Revives Xerox Alto Smalltalk-76 to Demo Modern IDE Origins

Computer History Museum

Ingalls demonstrates how Smalltalk-76 traded raw execution speed for dynamic message passing, cutting programming turnaround times by 90% and establishing the archetype for modern interactive development.

AI-assisted summary of Yesterday's Computer of Tomorrow: The Xerox Alto │Smalltalk-76 Demo — original source. Check the original for full context.

Source published: 2017-12-14

Key ideas

Smalltalk-76 served as the foundational archetype for modern Integrated Development Environments (IDEs), integrating interactive multi-font text, dynamic pop-up menus, class browsers, inspectable execution contexts, and debuggers into a single unified system. (0:33)
The reflective architecture of Smalltalk-76 allowed live modification and instant recompilation of running code without relinking, enabling rapid development turnaround times estimated at one-tenth of competing contemporary systems. (7:20)
Beyond graphical interfaces, Xerox PARC pushed the Alto hardware to support real-time 30-sprite animations, FM audio synthesis, and custom-wired organ hardware interfaces before industry standards like MIDI existed. (12:27)
Educational research driven by Alan Kay and Adele Goldberg demonstrated that middle school students could master Smalltalk-76 to program their own authoring tools rather than just consuming software. (14:48)

Detailed notes

## Background Published by the Computer History Museum on YouTube on December 14, 2017, this video captures a presentation and live demonstration recorded on November 10, 2017. The session features Dan Ingalls demonstrating and discussing Smalltalk-76, the revolutionary programming language and development environment developed at Xerox PARC.

## TL;DR Software pioneer Dan Ingalls demonstrates Smalltalk-76 operating on restored Xerox Alto hardware, showcasing how it established the foundational model for modern integrated development environments. Through live coding, he illustrates the system's pure object-oriented message-passing architecture, reflective virtual machine inspection, arbitrary-precision arithmetic, and instant turnaround time when modifying graphics routines live. The presentation also surveys groundbreaking multimedia achievements at Xerox PARC's Learning Research Group, including early bitmap painting with 'fat bits,' multi-sprite animation, real-time FM sound synthesis, and Adele Goldberg's classroom initiatives teaching junior high students to author their own software tools.

## Atmosphere & style The presentation carries an affectionate, reverent, and quietly astonishing tone, blending masterclass technical depth with the warm nostalgia of computing's golden age of discovery. Watching Ingalls interact with a four-decade-old operating system feels remarkably fresh and fluid, punctuated by relaxed developer humor about CPU-saving black screens and rapid-fire live patching. The session evokes a genuine sense of wonder at how modern and cohesive Xerox PARC's vision was, culminating in a joyful, celebratory mood as jaunty organ tunes like 'The Happy Hacker' bring the historic lab back to vibrant life.

## Bulletin - [00:33](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=33s) Smalltalk-76 served as the foundational archetype for modern Integrated Development Environments (IDEs), integrating interactive multi-font text, dynamic pop-up menus, class browsers, inspectable execution contexts, and debuggers into a single unified system. - [07:20](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=440s) The reflective architecture of Smalltalk-76 allowed live modification and instant recompilation of running code without relinking, enabling rapid development turnaround times estimated at one-tenth of competing contemporary systems. - [12:27](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=747s) Beyond graphical interfaces, Xerox PARC pushed the Alto hardware to support real-time 30-sprite animations, FM audio synthesis, and custom-wired organ hardware interfaces before industry standards like MIDI existed. - [14:48](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=888s) Educational research driven by Alan Kay and Adele Goldberg demonstrated that middle school students could master Smalltalk-76 to program their own authoring tools rather than just consuming software.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=0s) Dan Ingalls, principal architect of five generations of Smalltalk, demonstrated Smalltalk-76 running on reconstructed Xerox Alto hardware. - [00:33](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=33s) Smalltalk-76 established the modern IDE archetype by unifying a multi-font text editor, source-level browser, debugger, and object inspector in one environment. - [00:33](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=33s) To accelerate compilation, the Xerox Alto temporarily blanked its display refresh cycles to free up processor cycles for code execution. - [02:28](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=148s) Arithmetic in Smalltalk supports automatic promotion from standard integers to arbitrary-precision large integers through uniform polymorphic message passing. - [02:28](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=148s) Everything in Smalltalk operates via dynamic message passing to objects, enabling methods like factorial to function identically regardless of the receiver's concrete numeric type. - [04:25](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=265s) Stack frames ('contexts') are treated as first-class objects within the virtual machine, greatly simplifying the creation of reflective debugging tools. - [04:25](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=265s) Smalltalk-76 was bootstrapped by initially simulating its virtual machine bytecode dispatcher in Smalltalk-74 before optimizing it in microcode. - [07:20](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=440s) Dynamic message resolution eliminates static relinking phases, resulting in rapid code recompilation and turnaround times approximately a tenth of competing labs. - [11:11](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=671s) Smalltalk-76 introduced virtual workspace containers known as 'doors' or projects to organize distinct task environments and windows. - [11:11](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=671s) The integrated bitmap editor featured a 'fat bits' zoomed view that updated actual-size illustrations concurrently in real time. - [12:27](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=747s) Xerox Alto microcode powered complex animation systems capable of handling 30 simultaneous sprites and frame-by-frame onion skinning. - [14:02](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=842s) The Learning Research Group implemented software-based FM synthesis and interactive timbre editing to render polyphonic real-time music on the Alto. - [14:48](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=888s) Adele Goldberg and Alan Kay conducted classroom trials with local junior high students, proving children could write custom software authoring tools using object-oriented principles. - [15:36](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=936s) Prior to the creation of MIDI, the PARC team integrated musical instruments by directly hardwiring an organ keyboard into the Alto's input bus registers.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=0s) Introduction of Dan Ingalls

The presentation begins with an introduction of Dan Ingalls, celebrated as the principal architect of five generations of the Smalltalk programming language and environment. His foundational work began at Xerox PARC (Palo Alto Research Center) and has extended through decades of software design, including his recent work at Y Combinator on the Lively Kernel and Lively Web environments.

[00:33](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=33s) Live Demo of Smalltalk-76 and the Archetypal IDE

Dan Ingalls begins his live demonstration of Smalltalk-76 running on reconstructed hardware. He explains that Smalltalk-76 evolved from earlier versions of the language to become the archetype for what we now know as an Integrated Development Environment (IDE). The system seamlessly integrates interactive multi-font text, a source-level code browser, a debugger, and object inspectors. To demonstrate the "live" nature of the environment, Ingalls shows that any text on the screen can be selected and evaluated on the fly using pop-up menus.

During the evaluation of a simple expression, the screen briefly flashes black. Ingalls explains this quirky behavior with a bit of developer humor: "the Alto runs faster when it's not displaying its full screen," meaning the processor was freed from display-refresh cycles to compile and execute the code faster. The system successfully compiles the text, enters it as a method, and evaluates it. To show the system's robustness, Ingalls evaluates `20 factorial`. Smalltalk handles this easily because, unlike many languages of its era, it supports both standard small integers and arbitrary-precision large integers, returning a massive, exact numerical result.

* **Key Features of Smalltalk-76 IDE:** Multi-font text editor, source-level browser, debugger, and object inspectors. * **Hardware Optimization:** The Alto's screen is temporarily blanked during compilation to save CPU cycles and speed up execution. * **Integer Support:** Automatic promotion from small integers to extended-precision large integers.

[02:28](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=148s) Message Passing and the Factorial Method

Ingalls navigates the system's online source code to show how the factorial method is actually implemented. Using the system browser, he selects the `Number` class and points out its subclasses, which include standard `Integer`, `LargeInteger` (used for the previous calculation), and even classes like `Date` and `Time` which inherit numerical properties like comparison.

```mermaid flowchart TD accTitle: Smalltalk Factorial Message Flow accDescr: Flowchart showing how the factorial message is processed recursively using message passing. A["Receiver (self)"] --> B{"self = 0?"} B -->|True| C["Return 1"] B -->|False| D["Calculate self - 1"] D --> E["Send 'factorial' to (self - 1)"] E --> F["Multiply self by result"] F --> G["Return product"] ```

He opens the `factorial` method under the arithmetic category to explain its syntax. In Smalltalk, everything is accomplished by sending messages to objects. The expression checks if `self` (the receiver of the message) is equal to `0`. If true, it returns `1`; otherwise, it multiplies `self` by the factorial of `self - 1`. Ingalls emphasizes that this elegant, unified approach was revolutionary for the time.

> “What's notable about this is that in conventional programming at the time none of this would have worked for both small integers and large integers but in this case each of these things that's like the equal test the multiplication the subtraction those were all sent as messages so that this method actually works regardless of what the type of the receiver is”

[04:25](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=265s) Probing the Meta-System and the Virtual Machine

Ingalls demonstrates the power of Smalltalk's modeless text editor and its fully exposed meta-system. Because the entire system is live and reflective, a developer can probe into any running method. He demonstrates this by extracting and displaying the raw bytecodes of the `factorial` method directly on the screen.

He explains that every procedure execution in Smalltalk creates a live stack frame, which the system refers to as a "context." Because these contexts are first-class objects, developers can inspect and manipulate them directly, which made building an interactive debugger incredibly straightforward. Ingalls opens the `Simulation` category to show the `step` method of the virtual machine. This method simulates the execution of the system by advancing the program counter, fetching the next bytecode from the method, and dispatching it. He shares a historical anecdote about how Smalltalk-76 was bootstrapped.

> “And this is actually how Smalltalk-76 was created because we first wrote this method in Smalltalk-74 and we got it all working it was very slow but we got it all working and then then we wrote micro code for it and it runs the way it does now...”

[07:20](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=440s) Live Graphics and Rapid Turnaround Time

To demonstrate the ease of graphics programming, Ingalls evaluates a simple line of code: `Rectangle fromUser comp`. This prompts the user with a cursor to draw a rectangle anywhere on the screen, which then complements (inverts) the pixels beneath it. By drawing a second rectangle with a slight offset, he shows a "cheap way to put a border around a rectangle."

This leads to an insightful story about user experience. When normal end-users made large selections in early Alto systems, they often got scared by the "big black hole" that appeared on their screen. Ingalls decides to modify the system live so that selections draw an outline instead of a solid black block. He navigates to the `Selection` category of `TextImage` and modifies the `compRect` method. He adds a line of code to copy the rectangle, translate it by an offset of `-2 @ -2` (using the `@` operator to create a Point object), and complement it.

Upon recompiling, the change takes effect instantly. Ingalls explains that compilation in a message-oriented system is incredibly fast because there is no need for a slow relinking phase—messages resolve dynamically.

> “We often said that the Smalltalk systems ran at about a quarter the speed of other systems that are competing labs were building but the turnaround time for change was like a tenth or less.”

[11:11](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=671s) Overlapping Windows, Projects, and Bitmap Editing

In addition to overlapping windows and pop-up menus, Smalltalk-76 featured a project-organizing concept that some users referred to as "doors." These "doors" allow users to step into entirely separate virtual workspaces or "worlds" to keep different projects organized. Ingalls enters one of these projects to demonstrate a graphics and bitmap editor that was built long before most commercial paint programs existed.

The bitmap editor features a "fat bits" mode, which displays a zoomed-in pixel grid. Ingalls notices that a finger on an instrument in the drawing looks a bit too flat, so he uses the mouse to edit the pixels in the fat-bits view. True to Smalltalk's philosophy of liveness, the main, actual-size illustration updates in real-time as he clicks individual pixels.

[12:27](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=747s) Animation, Sprites, and Music Synthesis

Ingalls transitions from the live demo to showing historical video clips of other advanced systems built on the Alto. The first is an animation system that utilizes the power of the Alto's microcode. A user draws a ball, uses an iconic menu to trace a path, and watches the ball bounce along the curve. To make the animation more realistic, the system supports a "step mode" (onion skinning) where the user can see the previous frame on the left while drawing a squashed version of the ball on the right.

He then shows a full-speed demo of the animation system running about 30 sprites simultaneously, featuring a flying horse and the Cookie Monster gobbling up cookies. This system was built by Alan Kay and some collaborators from Canada. Finally, Ingalls highlights their work on music synthesis. Because the team loved music, they implemented real-time wavetable synthesis using the Alto's microcode, successfully generating ten voices in real-time, with contributions from Steve Saunders.

[14:02](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=842s) FM Synthesis and the Timbre Editor in Smalltalk-76

Dan Ingalls transitions from graphics to audio capabilities on the Alto, highlighting the work done to expand the machine's sonic palette. A student working with the Learning Research Group figured out how to implement frequency modulation (FM) synthesis, which opened up an entirely new realm of complex acoustic textures and synthesized instruments. Ingalls shows an interactive timbre editor running on screen, which allows the user to adjust and select various modulation ratios to produce diverse timbral qualities. To showcase the real-time processing capabilities of the system, he displays a real-time visual score while the Alto synthesizes a Bach fugue across four distinct polyphonic voices.

```mermaid flowchart LR accTitle: Real-Time Audio Synthesis in Smalltalk-76 accDescr: Pipeline showing frequency modulation ratio selection in the timbre editor leading to real-time four-voice polyphonic playback. subgraph Editing["Timbre Editing"] A["User Input / Modulation Ratios"] --> B["Timbre Editor Interface"] end subgraph Synthesis["Audio Synthesis Engine"] B --> C["FM Sound Generator"] C --> D["4-Voice Bach Fugue Playback"] C --> E["Real-Time Visual Display"] end ```

- A visiting student devised a method to run software frequency modulated (FM) sound synthesis directly on the Alto architecture. - The dedicated timbre editor provided direct visual control over modulation ratios to shape the harmonic spectrum of synthesized voices. - The demonstration featured a live four-voice polyphonic synthesis running concurrently with a real-time animated display of a Bach fugue.

---

[14:48](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=888s) Teaching Smalltalk: Adele Goldberg and the Jordan Junior High Classroom

Moving to the pedagogical roots of the project, Ingalls emphasizes that educational experimentation was central to the entire endeavor at Xerox PARC. Alan Kay and Adele Goldberg shared an intense dedication to discovering how children could grasp and shape computing environments. Ingalls presents historical footage of seventh- and eighth-grade girls from Jordan Junior High School working in a dedicated computer lab set up in the basement of the Hillview facility. Adele Goldberg is seen actively guiding the students through projects, serving as a demanding yet supportive mentor. The students became deeply engrossed in creating interactive graphics and music, moving beyond simply consuming software to constructing their own authoring applications. Pointing out a student named Marian, Ingalls notes that she was not merely drawing geometric shapes, but was actively programming her own polygon-construction tool to use for digital artwork. As Dan Ingalls puts it:

> “And a big part of our focus and Alan's passion and Adele's also was to teach and learn what we could from kids learning to use Smalltalk.”

- Alan Kay and Adele Goldberg directed classroom research projects to evaluate the expressive limits of Smalltalk when put into the hands of young learners. - The lab occupied the basement of the Hillview building, populated with Xerox Alto workstations and middle school students from nearby Jordan Junior High. - Adele Goldberg acted as both instructor and coach, pushing students to think systematically about object-oriented construction. - Student projects quickly evolved from basic procedural drawings into reusable authoring tools, such as custom polygon generators programmed from scratch.

---

[15:36](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=936s) "The Happy Hacker" and the Alto Organ Interface

To conclude the presentation, Ingalls takes the audience on a visual and musical tour of the Hillview basement lab, underscored by the Learning Research Group's informal anthem, "The Happy Hacker." The piece was composed, programmed, and performed live by group member Chris Jeffers. As the jaunty track plays, Ingalls asks the audiovisual crew to crank up the volume and points out an electric organ keyboard in the footage. Rather than using an off-the-shelf MIDI standard—which did not yet exist—the team had custom-wired the keyboard's key switches directly into the Alto's input bus, mapping keyboard presses straight into the machine's bit registers to trigger synthesis routines in real time. The session wraps up with the song concluding to enthusiastic applause from the audience.

- The group's lighthearted theme piece, "The Happy Hacker," was composed and performed by Learning Research Group member Chris Jeffers. - The musical setup featured an organ keyboard wired directly into the Alto's hardware bit registers to capture key presses with low latency. - The demonstration wraps up the Smalltalk-76 retrospective by highlighting how deeply integrated interactive graphics, live sound synthesis, and end-user programming were in PARC's early environment.

## Notable quotes > [07:20](https://www.youtube.com/watch?v=NqKyHEJe9_w&t=440s) We often said that the Smalltalk systems ran at about a quarter the speed of other systems that are competing labs were building but the turnaround time for change was like a tenth or less. — Dan Ingalls

## Mentioned Dan Ingalls, Alan Kay, Adele Goldberg, Chris Jeffers, Steve Saunders, Johann Sebastian Bach, Xerox PARC, Xerox Alto, Smalltalk-76, Smalltalk-74, Learning Research Group, Jordan Junior High School, Computer History Museum, Y Combinator, Lively Kernel, Lively Web, The Happy Hacker, Cookie Monster

## Video description Demonstration and discussion of the programming language and environment "Smalltalk-76” with Dan Ingalls. Recorded November 10, 2017. A recording of the full event is available here: https://youtu.be/4m_GhapEBLQ

[Source](https://www.youtube.com/watch?v=NqKyHEJe9_w)

中文简报

丹·英格尔斯重现施乐 Alto 上的 Smalltalk-76，展示现代 IDE 起源英格尔斯展示了 Smalltalk-76 如何以牺牲原始执行速度为代价换取动态消息传递，使编程周转时间缩短 90%，并奠定了现代交互式开发的原型。软件先驱丹·英格尔斯（Dan Ingalls）在修复后的施乐 Alto 硬件上演示了 Smalltalk-76 的运行，展示了它是如何确立现代集成开发环境（IDE）的基础模型的。通过现场编码，他阐释了该系统的纯面向对象消息传递架构、反射式虚拟机检查、任意精度算术，以及实时修改图形例程时的瞬时周转能力。此外，本次演示还回顾了施乐帕洛阿尔托研究中心（Xerox PARC）学习研究组取得的开创性多媒体成果，包括早期的“胖像素（fat bits）”位图绘制、多精灵动画、实时调频（FM）声音合成，以及阿黛尔·戈德堡（Adele Goldberg）教授初中生编写自用软件工具的课堂实践。 Smalltalk-76 是现代集成开发环境（IDE）的基础原型，将交互式多字体文本、动态弹出菜单、类浏览器、可检查的执行上下文和调试器整合到了一个统一的系统中。 (0:33) Smalltalk-76 的反射式架构允许在无需重新链接的情况下，对运行中的代码进行实时修改和即时重新编译，从而使开发周转时间大幅缩短，据估计仅为当时竞争系统的十分之一。 (7:20) 除图形界面之外，施乐 PARC 还将 Alto 硬件的极限推升至支持实时 30 个精灵（sprite）动画、FM 音频合成，并在 MIDI 等行业标准出现前就支持定制接线的风琴硬件接口。 (12:27) 由艾伦·凯（Alan Kay）和阿黛尔·戈德堡（Adele Goldberg）主导的教育研究表明，中学生完全能够掌握 Smalltalk-76，并编写属于自己的创作工具，而不仅仅是作为软件的使用者。 (14:48)

Reading summary

Dan Ingalls demonstrated Smalltalk-76 on reconstructed Xerox Alto hardware, showing how its message-passing architecture, reflective programming environment, and real-time multimedia capabilities established the foundational paradigm for modern integrated development environments and personal computing. The Live IDE and Reflective Message-Passing (0:33) Smalltalk-76 served as an early archetype for the integrated development environment by unifying interactive multi-font text editing, source browsing, debugging, and object inspection into a single live interface. Users could highlight any on-screen code expression and evaluate it dynamically through pop-up menus. Ingalls illustrated this with a factorial calculation (`20 factorial`), which automatically promoted standard integers into arbitrary-precision large integers. This behavior stemmed from Smalltalk's universal message-passing design. Instead of relying on rigid, primitive type checks, arithmetic operations such as equality tests, subtraction, and multiplication were dispatched as messages to objects. Consequently, the same factorial method worked seamlessly across diverse numerical receiver types. Furthermore, procedure executions generated live stack frames, known as contexts, which were treated as first-class objects. This fully exposed meta-system allowed developers to inspect raw bytecodes and trace execution directly within running applications. Rapid Turnaround Over Raw Execution Speed (4:25) Ingalls highlighted a deliberate architectural trade-off: Smalltalk systems executed at roughly one-quarter the speed of competing lab environments, but their turnaround time for code modifications was one-tenth or less. Because message-oriented systems resolve method bindings dynamically, developers did not have to wait for time-consuming relinking phases before changes took effect. To optimize execution on constrained hardware, the Alto briefly blanked its display during compilation, freeing the processor from refresh cycles. Ingalls demonstrated this iterative speed by modifying how text selections were rendered on the fly. To prevent users from being alarmed by a solid black block, he updated the `compRect` method in the `Selection` class to apply a offset point (`-2 @ -2`), instantly switching the selection highlight from a black fill to a bordered outline. He also noted that Smalltalk-76's virtual machine was originally bootstrapped by simulating its bytecode execution routine within Smalltalk-74 before being implemented in microcode. Integrated Multimodal Media and Custom Hardware (11:11) Beyond software development tools, the Alto environment accommodated sophisticated real-time graphics and audio synthesis. Smalltalk-76 supported overlapping windows and project "doors" that allowed users to isolate distinct workspaces. Within these projects, Ingalls showcased an early bitmap editor with a pixel-level "fat bits" view that updated the full-scale image in real time. Historical demonstrations also featured microcode-assisted animation capable of rendering roughly 30 concurrent sprites alongside frame-by-frame onion skinning. Sound was treated as an equally integral component of the workstation. Xerox PARC researchers implemented real-time ten-voice wavetable synthesis via microcode, followed by a software frequency modulation (FM) engine developed with a student researcher. This setup included a graphical timbre editor for altering modulation ratios while synthesizing polyphonic pieces, such as a four-voice Bach fugue, alongside live score visuals. To bypass the absence of commercial standards like MIDI, the team custom-wired an electric organ keyboard directly into the Alto's input bus registers, capturing keystrokes with low latency. Pedagogical Roots and End-User Tool Creation (14:48) Ingalls emphasized that the technical advances of Smalltalk were closely tied to educational research directed by Alan Kay and Adele Goldberg. The Learning Research Group operated an experimental laboratory in the basement of the Hillview facility, studying how middle school students from Jordan Junior High interacted with Alto workstations. Under Goldberg's guidance, the students progressed from passive consumers of software to active tool builders. Rather than merely executing procedural drawing commands, students learned object-oriented principles to build reusable software systems. For example, a student named Marian programmed a custom polygon-generation application from scratch to produce digital art, embodying the group's goal of placing general-purpose authoring power directly into the hands of non-expert users. Smalltalk-76 demonstrated that prioritizing rapid development turnaround, deep system reflectiveness, and low-latency multimedia could transform personal computing from a specialized calculation medium into an adaptable, accessible creative environment for programmers and novices alike.

精炼阅读摘要

Dan Ingalls 在计算机历史博物馆的演示中指出，Smalltalk-76 作为早期集成开发环境（IDE）的原型，通过纯粹的消息传递与反射式元系统，打破了当时静态编译的局限，实现了极短的系统修改与反馈周期。该平台不仅涵盖重叠窗口与实时多媒体合成，更在 Xerox PARC 作为教育实验载体，验证了普通用户与青少年自主构建创作软件的能力。集成开发环境原型与统一消息传递机制 (0:33) Smalltalk-76 将无模式多字体文本编辑器、源码级代码浏览器、调试器与对象检查器无缝融为一体，屏幕上的任意文本均可通过弹出菜单即时求值。在硬件限制下，Alto 计算机在编译期间会短暂黑屏以节省 CPU 刷新周期，但软件层面已支持小整数向任意精度大整数（LargeInteger）的自动升级，并能准确计算 20 的阶乘等庞大数值。更关键的突破在于纯粹的对象消息传递体系：系统将等值判断、减法与乘法均作为动态消息分发给接收对象（receiver），使得同一套递归阶乘代码无需针对特定类型重写，便可通用兼容普通整数与大整数。反射式元系统与极致的实时开发周转 (4:25) Smalltalk-76 具备完全暴露的元系统与自省能力，其每一次过程调用都会生成被称为“上下文”（context）的一等对象堆栈帧，开发者可直接在屏幕上提取、检查或操纵正在运行的方法字节码，这一机制极大简化了交互式调试器的实现。Smalltalk-76 最初完全在 Smalltalk-74 中模拟运行以完成自举，随后才通过 Alto 的微代码（microcode）大幅提升速度。根据 Ingalls 的说明，尽管 Smalltalk 系统的运行速度大约只有同期其他实验室系统架构的四分之一，但其代码修改周转时间缩短至十分之一甚至更低；由于消息在运行时动态绑定，开发者无需经历冗长缓慢的重新链接阶段，现场修改文本选区的高亮显示算法便能即时生效。图形界面、多任务工作区与位图编辑 (11:11) 在图形交互维度，Smalltalk-76 引入了重叠窗口以及被称为“门”（doors）的项目组织机制，允许用户在不同虚拟工作区（worlds）之间切换以管理复杂项目。系统内建了早于商业绘图软件的位图编辑器，并配备放大像素网格的“fat bits”模式，用户点击修饰乐器图案等细节时，实际尺寸的图像会实时同步渲染。此外，结合 Alto 的微代码支持，团队构建了具备洋葱皮（onion skinning）步进功能的动画系统，能够同时平滑调度约 30 个精灵图元（sprites）运行，展示了极具前瞻性的实时视觉交互能力。微代码声学合成与定制硬件整合 (14:02) Smalltalk-76 的多媒体表现不仅限于图像，团队还利用 Alto 微代码实现了 10 复音实时波表合成；Learning Research Group 的一名学生更进一步在 Alto 架构上开发出软件调频（FM）合成技术。通过专门的音色编辑器，用户可以直观调节调制比率以改变泛音结构，系统能够在屏幕实时渲染动态乐谱的同时，稳定合成包含四声部复音的巴赫赋格曲。在输入端，由于当时尚未出现 MIDI 行业标准，团队将一台电子风琴的物理开关直接硬连线到 Alto 的硬件输入总线与位寄存器上，从而消除了按键输入的延迟问题，支持即兴演奏与算法声音触发。面向青少年的教育计算实验与工具构建 (14:48) 教育探索是 Xerox PARC 研发 Smalltalk 的核心动力之一。Alan Kay 与 Adele Goldberg 致力于研究青少年如何理解和改造计算环境，并在 Hillview 大楼地下室设立了配备 Alto 工作站的电脑实验室，引导来自 Jordan 初中的七八年级学生进行系统化面向对象实践。Goldberg 担任指导与导师角色，推动学生跨越单纯软件使用者的界限；历史影像记录显示，学生不仅能独立编写交互式图形与音乐程序，甚至从零构建出可复用的多边形绘图生成工具，证明了以高交互性和统一对象模型为基底的系统对新手开发者的高表达力。 Dan Ingalls 的回顾展示了现代个人计算与集成开发工具的诸多源流，同时体现出 Smalltalk-76 刻意以牺牲一定绝对运行效率为代价，换取软件高自省性、实时响应与极低迭代成本的设计权衡；现场历史回顾也反映出在硬件受限的 1970 年代，软硬件协同定制对支持实时声画处理至关重要。

Source quotes

[7:20] Dan Ingalls: We often said that the Smalltalk systems ran at about a quarter the speed of other systems that are competing labs were building but the turnaround time for change was like a tenth or less.

Original transcript

[0:00] our final demonstration is of the [0:02] programming language and environment [0:04] small talk presented by dan angles dan [0:08] is the principal architect of five [0:10] generations of small talk beginning with [0:13] his crucial work at Parc most recently [0:16] Dan worked at Y Combinator on his latest [0:19] software environments the lively kernel [0:22] and the lively web please join me in [0:25] welcoming Dan [0:27] [Applause] [0:33] thank you I'm going to start by with a [0:36] live demonstration of the small talk 76 [0:39] system let me just type something here [0:53] and Smalltalk 76 had evolved from some [0:57] of our earlier Smalltalk work into what [0:59] became sort of the archetype for an [1:02] integrated development environment so it [1:04] includes interactive text multi font [1:10] text a source-level browsing system and [1:17] debugging and inspectors and other tools [1:21] and I'm just going to take a quick run [1:23] through um as with all of our software [1:26] we tried to keep everything as sort of [1:28] live and interactive as possible so for [1:31] instance wherever there was text you [1:33] could ask it to be evaluated and we got [1:36] pop-up menus we had done a lot of work [1:38] with graphics and and you'll see these [1:41] at like modern pop-up menus the screen [1:45] goes black there because this was sort [1:47] of for geeky development and it turns [1:49] out that the alto runs faster when it's [1:51] not displaying its full screen [1:55] so that things seem to be working that [1:57] has actually tested a great deal of the [1:59] system because it took that text [2:01] compiled it entered it into the system [2:03] is a method and then sent a message to [2:05] evaluate it here I'll take something a [2:08] little bit more a little bit more [2:10] challenging thing 20 factorial and in [2:15] the Smalltalk system there are small [2:17] integers but also there are general [2:20] large precision you know extended [2:22] precision integers so you can see that's [2:24] a very big result and we tried to keep [2:28] things as general as possible and let's [2:30] take a look at how factorial actually [2:32] works here's the we've got a category in [2:36] the system of numbers this this is [2:39] online access to all this software all [2:41] the software that's running in the [2:43] system and we see that here we've got [2:45] class number but also there are a number [2:48] of other classes here which which [2:51] inherit from number so there's regular [2:53] integers those are small valued ones [2:55] there's the large integers that were [2:57] used to compute that result and several [3:00] other things like dates and times which [3:01] also can do numerical things such as [3:06] comparison and and things like that if I [3:10] go here then here I've gone to the [3:15] category of arithmetic and I can look at [3:17] the factorial message and I'll take just [3:19] a minute to to show you you know how we [3:23] wrote that it's this involved having a [3:27] new language as well as a new evaluator [3:29] and so you'll need to understand a [3:31] little bit about how it works [3:33] everything's done by sending messages so [3:36] this is self in this case is receiving [3:38] the message factorial and what this [3:40] means is if I myself am equal to zero [3:43] and that's done by saying send equal to [3:45] me with with the argument 0 then return [3:49] 1 otherwise return myself times the [3:53] factorial of myself minus 1 so what's [3:56] notable about this is that in [3:58] conventional programming at the time [4:01] none of this would have worked for both [4:04] small integers and large integers [4:06] but in this case each of these things [4:08] that's like the equal test [4:10] the multiplication the subtraction those [4:13] were all sent as messages so that this [4:17] method actually works regardless of what [4:19] the type of the receiver is and it's fun [4:25] reviving a system like this because you [4:28] can do things like I can go into the [4:36] let's see I've let me just stop [4:38] sorry i mistyped something our text [4:46] editor is modeless the only way to go [5:03] so I could go and an INT and probe into [5:06] the system and ask for the method for [5:08] factorial and then ask for it as bytes [5:11] if I happen to want to do that [5:27] and there it is the actual byte codes [5:29] for that method which probably wouldn't [5:31] be that interesting to you unless you [5:33] were doing research on Smalltalk 76 but [5:37] if you were curious you could find out [5:39] because this system is all live and the [5:41] whole meta system is running all the [5:43] time so for instance let me cancel that [5:47] and we can go to the kernel classes and [5:50] this is where classes are described in [5:53] the inheritance and how it works but [5:54] even the even the the execution of every [5:58] procedure created a stack frame and the [6:01] sex stack frames we call them contexts [6:04] we're live so that you could actually [6:06] look at them and that made it incredibly [6:08] easy to build a debugger for this system [6:10] but I'm gonna go in in the category for [6:12] simulation and if you have an object [6:17] that represents the stack frame and and [6:21] you want to advance it say in the [6:23] debugger or if and simulate how the [6:25] system works [6:26] you would send that this message step [6:29] and it's a big piece of code I'll just [6:32] say a couple of words about it but it [6:34] says advance the program counter advance [6:36] the PC to be PC plus one go into the [6:39] method and pull out the byte that's [6:41] there okay and then dispatch on it [6:45] see what its value is and do this or [6:47] this or this or that so here is actually [6:49] the the entire the entire description of [6:53] how the Smalltalk virtual machine works [6:55] and this is actually how Smalltalk 76 [6:58] was created because we first wrote this [7:01] method in Smalltalk 74 and we got it all [7:05] working it was very slow but we got it [7:07] all working and then then we wrote micro [7:10] code for it and it runs the way it does [7:12] now so so we had a lot of fun with this [7:17] system just being able to try stuff out [7:19] very easily [7:20] I'll show you like that just the ease of [7:22] doing some graphic things like you could [7:25] say rectangle give me a new one and from [7:36] user take its dimensions from me and [7:40] then comp it come was short for [7:44] compliment meaning turn it turning black [7:47] on white or white on black so if I just [7:53] evaluate that while the system's running [7:57] it prompts me with a cursor and I can [8:00] draw out a rectangle just anywhere on [8:02] the screen and there we have that which [8:06] isn't that interesting but it did what I [8:08] wanted I can I can do the same thing [8:11] again and if I do it by it by a slight [8:15] offset that way I see who this is a [8:20] cheap way to put a border around a [8:23] rectangle and and that relates to one of [8:26] the things that was a problem working [8:30] with some end users with our system and [8:32] with some of the other Alto systems [8:35] which is that normal people when you [8:37] make a large selection get a little bit [8:39] scared by this big black hole in their [8:41] screen and mightn't it be nicer instead [8:44] to draw an outline around instead of [8:46] turning it all black so let's take a [8:49] look at what it would take to do that [8:50] let me cancel here and we'll go down to [8:55] another part of the system [9:03] this is the text image and it's got a [9:08] category called selection and their [9:10] various methods in there this one called [9:13] comp rect will reverse things from black [9:16] to white you can see it takes the [9:17] rectangle and says comp but I could add [9:20] to that code another line that would say [9:27] are copy [9:32] translate whoops translate by one and [9:46] this little operation just pronounced [9:50] make a point one so that makes an XY [9:54] coordinate pair that's an offset and [9:57] we'll tell that to come okay and now [10:02] I'll recompile this so we're down in the [10:09] deepest part of the system here making a [10:11] recompilation but the compilations are [10:13] always fast in a message oriented system [10:15] because there's no need to relink [10:17] everything messages do that [10:19] automatically and now I make this [10:20] selection and look at that and amazingly [10:28] amazingly it actually extends to another [10:31] area it might be nicer really to have [10:33] that offset be - just to show how you [10:36] know development goes so fast when [10:42] everything just responds immediately we [10:45] often said that the small dog systems [10:48] ran at about a quarter the speed of [10:51] other systems that are competing labs [10:53] were building but the turnaround time [10:55] for change was like a tenth or or less [10:58] so now let's see what we've got [11:02] yeah that's sort of nicer okay [11:06] so that's you know about how easy it is [11:10] to do development in the system I [11:11] thought I'd just show in addition to [11:14] overlapping windows and in pop-up menus [11:17] we also had a sort of a variant on [11:20] Windows which which some people called [11:22] doors which is you could go in two [11:24] separate worlds here and enter them so [11:28] you could actually have sort of all of [11:31] your projects organized in this in this [11:33] universe and here's a project in which [11:35] we're doing a little bit of graphics [11:38] editing and this is to show that we did [11:41] also do those things and this particular [11:44] editor was quite a while before a lot of [11:48] other bitmap editors but for instance [11:51] it's actually got a fat bits mode and I [11:53] could go this this finger on the on the [11:58] instrument just always look to me a [12:00] little bit flattened where it shouldn't [12:02] be so let me just try to make a change [12:05] to that here's the here's a fat bits [12:07] editor and I can go in with the mouse [12:09] and and turn this to be white and like [12:13] everything else we did we tried to keep [12:14] it live so you'll see it's actually [12:16] changing the the main picture while I do [12:18] this okay [12:27] so now you can you can start the video [12:29] I'm going to show videos for the rest [12:32] here some other work that we did that [12:35] use the power of the alto microcode this [12:40] is an animation system we did [12:43] here's we're drawing up throwing a ball [12:46] here and and then the animation system [12:50] itself also puts up an iconic menu and [12:54] here we've traced a curve for it and now [12:57] we set it to run that curve and you see [12:59] the ball bouncing but we'd like to make [13:01] it splay out at the bottom it would be [13:03] more effective if it did that so we [13:05] would go into step mode and take a copy [13:08] of that the ball at that point so that [13:11] we have it there so that we can do our [13:13] new image where it should be in the [13:17] animation so we've got live on the left [13:20] and we're doing the editing on the right [13:22] and you see there there's the squash [13:23] ball appearing ok have we've done by [13:30] Allen and and some guys who came down [13:32] from Canada here's the animation system [13:35] at full speed with about 30 sprites the [13:38] Cookie Monster gobbling cookies and a [13:40] flying horse of course [13:45] we got into doing a music synthesis just [13:49] because we could and we all liked music [13:51] so we worked on wavetable synthesis [13:54] which is we could get actually ten [13:56] voices in real time using the Altos [13:59] microcode but then Steve Saunders who is [14:02] a student with us figured out a way to [14:04] get frequency modulated sounds which is [14:07] it gives you a whole other set of sounds [14:10] that you can do and here's a Tambor [14:12] editor where we're choosing different [14:14] different ratios of the modulation to [14:17] get these different sounds and then [14:20] here's a real-time display being [14:23] synthesized with four voices in a Bach [14:25] fugue [14:26] [Music] [14:40] and you'll hear some more that synthesis [14:42] at the very end being played live but a [14:49] big part of our focus and Alan's passion [14:52] and Adele's also was to teach and learn [14:55] what we could from kids learning to use [14:58] small talk and this is these are girls [15:00] from a class at Jordan junior high who [15:03] worked we had the basement at Hill view [15:05] set up there's Adele she was a great [15:08] coach very insightful and challenging [15:10] and and these kids got so excited by [15:15] working with graphics and music I think [15:18] you can you can see the intention here [15:20] on their face so this Marion building [15:25] she's actually not just making polygons [15:29] but making a tool that makes polygons as [15:31] an artistic tool this and I thought it'd [15:36] be nice to finish up with a tour around [15:39] that basement classroom this the song [15:44] here is the theme song of our group the [15:46] happy hacker which was let's let's keep [15:49] the sound up which was written written [15:54] composed and is being played live by [15:56] Chris Jeffers please turn the sound up [15:58] thanks [16:02] and you'll see the organ there's the [16:04] organ keyboard that was fit actually [16:06] into the bits of the Alto [16:08] [Music] [16:39] Thanks thank you very much