Alan Kay (VPRI Co-founder) – Programming Languages and Programming (2013)
Chapters
00:00:51 Live Coding: A Simple Introduction to Programming Concepts
Programming Language Diversity: Thousands of programming languages have been designed and implemented over the years. At any given time since the early 60s, 150 to 200 languages have been in standard use. Languages differ in some ways and are similar in others, making generalizations challenging.
Defining Programming: Programming is the simple concept of “we do something, and the computer does something.” Success is achieved when the computer does what was intended. Programming languages are the usual vehicle for this process.
User Interfaces as Programming Languages: User interfaces can be seen as impoverished programming languages. Richer user interfaces allowed programming actions to be part of the interface.
Live Coding: Live coding allows for immediate feedback and response from the computer. It predates the punch card Unix approach and black screen, Vi-terminal style of programming. Live coding involves creating things in various ways and observing the computer’s response. There is no visible compiling or editing.
eToys and Symbolic View: eToys is a programming language used by millions of children. It features live coding and a symbolic view of objects. The symbolic view displays properties and behaviors of objects. The interface is reflexive, allowing changes in one view to be reflected in others.
Creating Objects with Behaviors: Objects can have properties and behaviors. Behaviors can be triggered by user actions or scripts. Scripts can be created by dragging out behavior blocks and connecting them. Compilation happens sub-second in the background, enabling instant feedback.
00:06:02 Exploring Programming and System Dynamics for Young Learners
Introduction of Graphical Objects and Steering: Alan Kay introduces the concept of graphical objects, represented as cars, that can be manipulated on a screen. A “steering wheel” object is created to control the movement of the car, demonstrating the use of different costumes and behaviors for objects. Kay emphasizes the importance of having a programming language that allows for quick and easy creation of objects and their manipulation.
Demonstration of Multitasking and Infection Programming: Kay showcases automatic multitasking, where multiple programs (cars) can run simultaneously. He creates a simple infection programming scenario where blue cars can infect red cars, and the infected cars change color. This demonstration highlights the concept of system dynamics, where the interactions between objects can lead to emergent behavior.
Exploring System Dynamics through Simulation: Kay encourages children to experiment with the infection programming scenario by varying the number of cars and observing the resulting dynamics. He emphasizes the importance of understanding system dynamics, particularly in the context of biological systems and contagious diseases. Kay uses AIDS as an example to illustrate how a disease with a long time constant can still have devastating consequences if not addressed early.
Importance of Systems Dynamics in Today’s World: Kay highlights the relevance of systems dynamics in today’s interconnected world, especially in biological systems. He suggests that policymakers should experiment with system dynamics models to gain a better understanding of complex systems and their potential instability.
Introducing Sensors and Robot Cars: Kay transitions to the creation of a simple robot car that can navigate a track. He adds a sensor to the car to track its position and demonstrates how a program can be created to control the car’s movement. Kay mentions the pedagogical value of such experiments, where children learn about feedback loops and navigation strategies.
00:14:21 Simple Algorithm for Sensing Boundary Walls
Finding the Wall: Alan Kay emphasizes the importance of immediately creating a program to detect the wall in a simulated environment to avoid losing track of its location.
Program Design: He introduces a simple program that continuously moves the car forward and checks if it touches the wall. The program uses the car’s blue color and the wall’s brown color to determine when a collision occurs.
Testing and Troubleshooting: Kay demonstrates the program and asks the audience to identify its flaw. He explains that the program may lose track of the wall if the car makes a sharp turn and is unable to regain contact with the wall due to its fixed radius.
Feedback Mechanism: Kay suggests adding a feedback mechanism to the program. He proposes slowing down the car or even stopping it when it loses the wall to increase the chances of reestablishing contact.
Creating Complex Behaviors: Kay expresses his intention to transform the program into a “wriggly worm.” He explains that this will require additional coding and design.
Introduction to eToys: eToys is a programming environment designed for children to learn and explore programming concepts. It features a user-friendly interface with visual elements and intuitive controls.
Creating Animated Objects: Alan Kay demonstrates the creation of a wriggly worm object using two different pictures. He introduces the concept of a data structure to store and alternate between the two pictures, creating the animation effect.
Metaprogramming in eToys: Kay introduces the idea of metaprogramming, which involves creating a new language within an existing one. He explains his intention to create a language specifically for particle system simulations within the eToys environment.
Implementation of the Particle System Language: Kay utilizes the animation system of eToys to execute instructions for the particle system language. He creates a test instruction that moves a blue guy and another instruction that turns both a blue guy and a red guy red if they collide.
Learning Programming through Metaprogramming: Kay emphasizes the importance of children learning how to program from an early age. He suggests that designing programming languages with children in mind can provide valuable insights for creating powerful and easy-to-use languages.
Computer Architecture and Virtual Machines: Kay discusses the different layers of computer architecture, from logic gates to microcode and virtual machines. He explains how a virtual machine like Smalltalk can make the computer behave like a Smalltalk machine, simplifying programming tasks.
The Role of Smalltalk and eToys: Kay briefly mentions Smalltalk as a programming language with a development system written in itself. He clarifies that the eToys system, which is used to present the slides, is also written in Smalltalk.
Different Approaches to Problem-Solving in Programming: Kay highlights two approaches to solving programming problems: writing tons of programs to address specific issues or finding languages that fit the problems gracefully. He suggests that the latter approach can lead to a more efficient and elegant solution.
Turing’s Idea of Simulation: Kay references Alan Turing’s concept of simulating any mechanism on a simple mechanism with limited logic and ample memory. He relates this idea to the eToys environment, which allows children to simulate complex systems using simple programming constructs.
00:26:05 Measuring Software Complexity by Lines of Code
Measuring Code Complexity: Alan Kay introduces “lines of code” as a metric for measuring code complexity and programmer effort. He compares the number of lines in a 400-page book (approximately 20,000 lines) to the lines of code in software systems.
Lines of Code in Notable Structures: A foot of books stacked up represents around 300,000 lines of code. A meter of books stacked up represents approximately 1 million lines of code.
The Empire State Building Analogy: The Empire State Building is approximately 22,000 books high, which translates to 440 million lines of code. This analogy highlights the immense scale and complexity of modern software systems.
Examples of Large-Scale Software Systems: Government systems often consist of hundreds of millions of lines of code. Microsoft’s operating system alone contains around 120 million lines of code. Microsoft Office adds another 100 million lines of code to the equation, totaling 220 million lines of code.
Complexity Challenges: The sheer volume of code in large software systems makes it challenging for any single person or group to comprehend and maintain the entire codebase. Much of the code may not even be actively used, but it remains in the system due to uncertainty about its potential impact if removed.
Code Complexity: Alan Kay discusses the complexity of software code, specifically questioning why 220 million lines of code are needed for certain features. He mentions that the original implementation at Xerox PARC only required 10,000 lines of code, highlighting the exponential increase in complexity.
Financial Products Company Example: Kay cites an unnamed large financial products company with over 400 million lines of code in its primary customer offerings. He emphasizes the outdated nature of their user interface, which still uses screens reminiscent of mainframe days. The company maintains 170,000 screens, equivalent to approximately 20,000 books or an Empire State Building’s worth of code.
Job Market Demand: Kay highlights the job market demand for programmers to maintain and manage these complex codebases. He emphasizes that businesses are hiring programmers not for innovation but to address the existing mess of legacy code.
Examples of Solutions: Kay intends to present examples of potential solutions to address the problem of code complexity within the remaining time of his presentation.
00:31:00 Evolution of Programming Languages and the Need for Higher-Level Abstractions
Machine Code and Higher-Level Languages: Machine code requires billions of lines of code to perform complex tasks due to its one-instruction-per-line nature. Higher-level languages like C allow for a more compact representation, with hundreds of millions of lines of code potentially replacing billions in machine code. Advanced higher-level languages can further reduce the code count to thousands of lines, simplifying programming tasks.
Programming Effort and Language Levels: The programming effort decreases as we move to higher-level languages. Computer science has not adequately addressed the need for invention in creating programming systems that significantly reduce programming work. The amount of work required for packaging, documentation, and debugging remains significant, regardless of the programming language used.
The Current State of Business Programming: Most business programming in the US is still done at the low level, similar to the practices of the 1960s. New programming languages have not substantially elevated the level of abstraction in business programming.
A Call for Research and Innovation: Despite the dominance of low-level programming, there are opportunities for researchers and innovators to explore higher-level abstractions. Studying the history of programming reveals exceptional individuals who transcend the limitations of their time.
00:34:38 Sketchpad: The First Interactive Computer Graphics System
Overview: This chapter discusses the 50th anniversary of the first interactive computer graphics system, Sketchpad, created by Ivan Sutherland in 1962. It highlights the system’s groundbreaking features, including interactive graphics, object-oriented design structures, and constraints for programming.
Inventor and Context: Ivan Sutherland, the inventor of computer graphics and object-oriented design systems, developed Sketchpad in one year as his PhD thesis. Sketchpad ran on a massive air defense computer, occupying a space comparable to the Franz Hall building. It was only accessible for use from 3 am to 6 am.
Features and Functionality: Sketchpad allowed users to create and manipulate graphical objects using a light pen and a simulated graphics display on an oscilloscope. It introduced the concept of constraints for programming, enabling users to define relationships between objects that the system would automatically maintain. Sketchpad featured the first implementation of a clipping window, allowing users to view a specific portion of a drawing. Objects drawn in Sketchpad could be designated as “masters,” and instances of those masters could be created with different sizes and orientations. The system also supported the creation of dynamic simulations, as demonstrated by a bridge simulation that calculated the bridge’s behavior based on physical constraints.
Legacy and Impact: Sketchpad’s contributions include the introduction of interactive computer graphics, object-oriented design structures, and constraint-based programming. The system’s influence can be seen in modern graphical user interfaces (GUIs), computer-aided design (CAD) software, and object-oriented programming languages. Sketchpad’s innovative ideas laid the foundation for the development of modern computer graphics and interactive computing.
00:43:01 Visualizing Dynamic Forces in Structures Using Interactive Simulations
Visualizing Structural Mechanics with Dynamic Simulations: Alan Kay demonstrated a dynamic simulation of a bridge structure, showcasing the ability to manipulate objects and observe the resulting stresses and strains. By dropping a weight onto the bridge, viewers could observe the ripple effect of the force across the structure, demonstrating realistic behavior similar to actual bridges.
Enhanced Display Capabilities: Modern displays allow for improved visual representation of simulations, including the addition of weight to letters and enhanced rendering capabilities.
Three-Constraint Programming Approach: The simulation was programmed using three constraints: gravity, spring tension, and pin constraints. Disabling or adjusting these constraints allowed for the exploration of different structural behaviors and the impact of various forces on the bridge.
Dynamic Behavior and Realistic Simulations: The simulation demonstrated the dynamic behavior of structures, including the ongoing oscillations and vibrations observed in real-world structures. Turning off constraints allowed for the observation of the structure’s collapse, highlighting the importance of these constraints in maintaining structural integrity.
00:46:16 Programming Language Design for the Future of Graphics
Overall Summary: Alan Kay emphasizes the importance of creating programming languages that are closely aligned with mathematical formulas and concepts, allowing for more efficient and understandable code. He demonstrates this by showcasing a graphics rendering system developed at Viewpoints, highlighting its compact programming language and visual debugger.
Programming Close to Mathematical Formulas: Kay advocates for programming languages that closely resemble mathematical formulas, enabling programmers to express their ideas more directly and concisely. He presents an example of a graphics rendering formula, along with a programming language that closely mirrors this formula. This approach reduces the amount of code needed to implement complex graphics operations, making it easier to understand and debug.
Visual Debugging Tools: Kay introduces a visual debugger automatically generated from the code, allowing developers to easily trace the flow of data and identify the source of errors. This visual debugger provides a graphical representation of the code, enabling developers to see how different parts of the program interact and affect the final output. By hovering over specific pixels or elements in the graphical representation, developers can quickly identify the corresponding code and data responsible for rendering those elements.
Importance of Debuggers in Future Languages: Kay emphasizes the need for programming languages of the future to include integrated debuggers. He argues that the development of debuggers should be an integral part of language design, rather than an afterthought. By providing visual and interactive debugging tools, developers can more easily understand and troubleshoot their code, leading to faster and more efficient development cycles.
Abstract
“Revolutionizing Computer Programming: The Evolution from Basic Coding to Advanced System Dynamics”
In the field of computer programming, the journey from simple code instructions to the advanced dynamics of system simulation represents a transformative evolution. This article delves into the intricacies of programming languages, the groundbreaking concept of live coding, and the innovative eToys programming language, highlighting its immediate compilation and object manipulation features. Pioneers like Alan Kay have been instrumental in introducing concepts such as automatic multitasking and system dynamics, pushing the boundaries of programming from basic compilation to complex simulations like robot cars and teaching children about system dynamics. The article also explores the legacy of Ivan Sutherland’s Sketchpad, a forerunner in interactive computer graphics and object-oriented design, which laid the groundwork for modern programming practices.
Main Ideas and Expanded Discussion:
The Essence of Programming Languages:
Programming languages, evolving beyond basic functionality, now encompass user interfaces akin to simplified programming languages. Over the years, thousands of programming languages have been designed, with 150 to 200 commonly in use at any time. At its core, programming embodies the concept of an action-reaction relationship between human input and computer response, facilitated primarily through these languages.
The Advent of Live Coding:
Emerging in the 1960s, live coding revolutionized traditional programming methods by enabling immediate feedback from code, eliminating the need for stepwise compiling or editing. This approach, anteceding the punch card Unix system and Vi-terminal style, fosters direct interaction with the computer, offering real-time response and eliminating visible compiling or editing steps.
eToys: A Child-Friendly Programming Language:
Millions of children globally have been introduced to programming through eToys, a language that simplifies programming with its live coding feature. This environment allows users to create and manipulate graphical objects, providing both graphical and symbolic views, thereby enhancing the understanding of programming concepts.
Introduction to eToys:
eToys serves as a child-friendly programming environment, offering a user-friendly interface with visual elements and intuitive controls. This approach enables children to learn and explore programming concepts in an engaging manner.
Creating Animated Objects:
Demonstrating eToys’ capabilities, Alan Kay illustrates the creation of a wriggly worm object using two different pictures. He introduces the concept of a data structure for storing and alternating between pictures, enabling the animation effect.
Metaprogramming in eToys:
Kay delves into metaprogramming, which involves creating new languages within an existing one. He aims to develop a language specifically for particle system simulations within eToys, showcasing the versatility of the environment.
Implementation of the Particle System Language:
Utilizing eToys’ animation system, Kay executes instructions for the particle system language. He demonstrates instructions that manipulate the behavior of graphical elements, such as changing colors upon collision, showcasing the interactive and dynamic nature of eToys.
Learning Programming through Metaprogramming:
Emphasizing the importance of early programming education, Kay advocates designing languages with children in mind, proposing that this approach could yield powerful and user-friendly programming languages.
Computer Architecture and Virtual Machines:
Kay discusses various layers of computer architecture, from logic gates to microcode and virtual machines. He explains how virtual machines, like Smalltalk, simplify programming tasks by emulating specific programming environments.
The Role of Smalltalk and eToys:
Kay notes that Smalltalk, a language with its development system written in itself, serves as the foundation for the eToys system, further highlighting the interconnectedness of these programming environments.
Different Approaches to Problem-Solving in Programming:
Highlighting two problem-solving strategies in programming, Kay contrasts the approach of writing numerous programs for specific problems with finding languages that elegantly fit the problems, suggesting that the latter can lead to more efficient solutions.
Turing’s Idea of Simulation:
Referencing Alan Turing’s concept of simulating mechanisms on simple systems, Kay relates this to the eToys environment, where children can simulate complex systems using straightforward programming constructs.
Code Complexity and Scale in Software Development:
Measuring Code Complexity:
Alan Kay introduces “lines of code” as a metric for assessing code complexity and programmer effort. He compares this to the content of a 400-page book and the scale of software systems.
Lines of Code in Notable Structures:
Kay draws analogies with the Empire State Building to illustrate the scale of modern software systems, with government systems and products like Microsoft’s operating system encompassing hundreds of millions of lines of code.
Complexity Challenges:
The immense volume of code in large software systems poses significant challenges in comprehension and maintenance, with much of the code remaining unused yet integral due to uncertainties about its removal.
The Problem of Code Complexity and the Explosion of Complication:
Kay addresses the exponential growth in software code complexity, comparing the modest requirements of early implementations at Xerox PARC to the massive scale of modern systems. He cites examples like a large financial products company with an outdated user interface, maintaining an overwhelming amount of code.
Job Market Demand:
The current job market in programming focuses more on maintaining and managing complex legacy codebases rather than on innovation, highlighting the need for streamlined and efficient coding practices.
Examples of Solutions:
Kay plans to present potential solutions to address the issue of code complexity, aiming to demonstrate more efficient and innovative approaches within the programming domain.
Rapid Compilation in eToys:
A notable feature of eToys is its sub-second compilation time, which facilitates nearly instant code execution. This rapid compilation, occurring in the background, fosters an interactive and responsive learning environment for users.
Conceptualizing Objects and Steering in Programming:
Alan Kay’s introduction of object creation in programming, exemplified by graphical objects like cars, revolutionized the way objects are manipulated within a programming language. The creation of a “steering wheel” object to control a car showcases intuitive object manipulation, emphasizing the need for programming languages that allow for quick and easy object creation and interaction.
The Principle of Automatic Multitasking:
Kay demonstrates automatic multitasking by running multiple programs (cars) concurrently. He uses a simple infection programming scenario to showcase system dynamics, where interactions between objects lead to emergent behaviors.
Understanding System Dynamics:
Emphasizing the importance of understanding system dynamics, Kay uses an infection model to illustrate the growth dynamics of biological systems. He encourages experimentation with this model to highlight the necessity for informed decision-making based on system understanding.
Experimentation with Robot Cars:
Kay’s robot car simulation uses sensors for navigation, demonstrating the practical application of programming in understanding real-world phenomena. He emphasizes the educational value of such experiments in teaching children about feedback loops and navigation strategies.
Educating Children on System Dynamics:
Through hands-on activities, children gain a practical understanding of feedback and control systems. Kay’s programming exercises, like navigating a room blindfolded, instill integral concepts in programming and real-world problem-solving.
Alan Kay’s Presentation on Programming and Metaprogramming:
Kay’s demonstration of creating animations in eToys and his discussion on metaprogramming reflect his commitment to making programming accessible and insightful for children. He also touches upon the hierarchical structure of computer systems and the importance of choosing appropriate programming languages for specific problems.
The Challenge of Code Complexity:
Kay’s analogies highlight the immense scale of code in large software systems, emphasizing the difficulty of managing and understanding these complex programming environments. This complexity necessitates innovative approaches to simplify and streamline coding processes.
Job Market and Legacy Systems:
Despite advancements, many programming job opportunities still revolve around maintaining and updating legacy systems, rather than fostering innovation in software development.
The Role of Higher-Level Languages:
Higher-level languages have the potential to drastically reduce programming effort. However, most business programming remains at a rudimentary level, indicating a significant gap in the application of advanced programming concepts.
Research and Innovation in Programming:
The need for innovative research in developing powerful and user-friendly programming systems is paramount. Kay encourages new generations of researchers to contribute to this evolving field.
The Legacy of Sketchpad and Interactive Computer Graphics:
Sketchpad, created by Ivan Sutherland in 1962, was a monumental step in computer graphics, introducing interactive design, object-oriented programming, and constraint-based programming. Its influence extends across various applications and continues to inspire technological advancement.
Bridge Simulation and System Visualization:
Kay’s bridge simulation using a simple graphical interface and subsequent stress and strain analysis demonstrate the power of programming in visualizing and understanding complex system dynamics.
Advanced Rendering and Interactive Programming:
The evolution of programming from static code execution to dynamic, user-driven experiences is marked by the use of advanced rendering techniques in simulations and the ability to interactively manipulate structures.
Programming Graphics for the Languages of the Future:
Looking ahead, programming graphics will become increasingly integral in future programming languages. The development of visual debugging tools and the importance of debuggers in these languages will play a crucial role in simplifying and enhancing the programming experience.
Background and Additional Information:
The journey of programming, from its humble beginnings to the advanced dynamics of modern simulations, reflects the continuous evolution of technology and its ever-expanding potential. The contributions of pioneers like Alan Kay and Ivan Sutherland have not only transformed how we understand and utilize programming but have also laid a foundation for future innovations. As we move forward, the challenge lies in harnessing these advancements to create more intuitive, efficient, and powerful programming languages and systems, thereby shaping the future of technology and its impact on society.
Alan Kay's vision for personal workstations emphasized powerful tools for creativity and learning, leading to milestones like Smalltalk and the graphical user interface. His Dynabook concept aimed to provide information access anywhere, inspiring the development of modern portable devices....
Insights from pioneers like Alan Kay and Joe Armstrong reveal the evolution of computing, emphasizing the importance of learning, scaling, and addressing unsolved problems. Computer scientists should think like scientists, considering scaling aspects early and embracing failure to drive innovation....
Alan Kay emphasized strategic thinking in software engineering with a focus on domain-specific languages, criticized current computing systems, and envisioned dynamic and efficient computing in the future. Kay highlighted the need for strategic thinking in software engineering with a focus on domain-specific languages, criticized current computing systems, and envisioned dynamic...
Alan Kay's revolutionary concepts, such as the Dynabook and Smalltalk, shaped modern computing and inspired future innovations, while his emphasis on open knowledge and transformative teaching fostered creativity and critical thinking in his students. His insights into early computers and programming languages laid the groundwork for modern object-oriented programming and...
Alan Kay, a pioneer in object-oriented programming, emphasized the significance of holistic approaches, creativity, architectural integrity, and continuous innovation in programming. Smalltalk's influence extends beyond syntax and libraries, embodying architectural principles and structural integrity, akin to the construction of the Chartres Cathedral....
Alan Kay, a Turing Award laureate, advocates for a practical, hands-on approach to computer science education, emphasizing simplicity, systems thinking, and a beginner's mindset. He calls for a shift from theoretical rigor to practical problem-solving, preparing students to contribute to the advancement of computing....
Alan Kay critiques modern computer science for emphasizing form over content and calls for a paradigm shift towards innovation and user-centric design. He advocates for a holistic approach to education that fosters creativity, perspective, and epistemological frameworks to drive the future of computing....