| HN Mirror

Many visual programming languages don't necessarily display a connected graph of nodes, or explicit visual code beyond the data you're acting on.

What many people don't realize about visual programming languages is that there are so many of them that look and behave extremely differently than the few recent and popular ones they might have actually seen and used, like Unreal Blueprints.

People have been inventing wildly diverse VPLs for a long time, and there is no one standard visual design (like graphs with boxes and arrows, interlocking blocks, text, images, etc) or execution model (like data flow, control flow, cellular automata, constraints) or interface style (like keyboard, mouse, dialog panels, notebook, direct manipulation, demonstration or example) that defines the genre.

Your narrow definition of VPL excludes not only spreadsheets but also Visual Programming by Example (VPBE), Programming by Demonstration (PBD), and Visual Constraint Programming (VCP), topics that Brad Myers and others have studied, researched, and written code and papers about for decades.

It also excludes groundbreaking influential work like Ivan Sutherland's 1963 "Sketchpad" PhD thesis that pioneered Visual Constraint Programming and many other advanced interaction techniques.

VPBE and PBD enable users to teach the computer new behaviors by demonstrating actions on the interface, rather than by writing code explicitly. This approach is inherently visual and interactive, focusing on the outcomes of actions to infer the underlying logic or procedures.

Brad Myers' 1987 PhD thesis "Creating User Interfaces by Demonstration" is one of his early and influential works in the field of PBD. It discusses the design, implementation, and evaluation of Peridot, a system that allows users to create user interfaces by demonstrating actions instead of writing code.

https://books.google.nl/books/about/Creating_User_Interfaces...

Peridot Full 1987:

https://www.youtube.com/watch?v=FsGx7G72V0Q

>Peridot was a system for creating User Interfaces that was created between 1985 - 1987. This video was previously published as: Brad A. Myers. Creating User Interfaces by Demonstration: The Peridot UIMS. Technical Video Program of the SIGCHI'88 Conference, Washington, D.C., May 15-19, 1988. and IFIP Interact '87 Conference on Human-Computer Interaction. Stuttgart, West Germany. Sept. 1-4, 1987. SIGGRAPH Video Review, Issue 59, no. 2.

"Demonstrational Interfaces: Sometimes You Need a Little Intelligence, Sometimes You Need a Lot" (1998): In this article, Myers explores the concept of demonstrational interfaces, which are a subset of intelligent user interfaces that allow users to demonstrate actions to achieve goals. The paper discusses the spectrum of intelligence required in such systems, from minimal to substantial, depending on the task complexity.

https://www.sciencedirect.com/science/article/abs/pii/B97815...

"Garnet: Comprehensive Support for Graphical, Highly Interactive User Interfaces" (1990, IEEE Computer): Myers and his colleagues introduced Garnet, a toolkit for creating graphical, interactive user interfaces. Garnet supports PBD in the context of UI development, making it easier for developers to create and manipulate UI elements.

https://www.cs.cmu.edu/afs/cs.cmu.edu/project/garnet/www/gar...

I worked with Brad on Garnet at CMU, wrote about it on HN, and wrote a comparison of Garnet and OpenLaszlo:

https://news.ycombinator.com/item?id=11232154

Constraints and Prototypes in Garnet and Laszlo:

https://web.archive.org/web/20070207232741/http://www.donhop...

"Constraints are like structured programming for variables":

https://news.ycombinator.com/item?id=11232154

"Programming by Example: Intelligence in Demonstrational Interfaces" (1992, Communications of the ACM): This paper discusses the role of intelligence in demonstrational interfaces, emphasizing how such systems can infer user intentions from examples to automate tasks and create programs.

https://dl.acm.org/doi/10.1145/330534.330545

"Past, Present, and Future of User Interface Software Tools" (2000, ACM Transactions on Computer-Human Interaction): Although not solely focused on PBD, this paper, co-authored with Scott E. Hudson and Randy Pausch, provides an extensive overview of user interface software tools, including those that incorporate principles of programming by example and demonstration.

https://dl.acm.org/doi/10.1145/344949.344959

Myers has contributed to several books either as an author or editor, covering topics related to user interface design, software development, and PBD. One example is "Watch What I Do: Programming by Demonstration," which Myers edited. This book is a comprehensive overview of the field of programming by demonstration, featuring chapters by various authors on different PBD systems and theories.

https://www.e-booksdirectory.com/details.php?ebook=3365

Ivan Sutherland developed "Sketchpad" as his PhD thesis at MIT in 1963, which is often considered one of the earliest examples of visual programming. Sketchpad was revolutionary for its time, introducing concepts that laid the groundwork for interactive computer graphics, graphical user interfaces (GUIs), computer-aided design (CAD) systems, and indeed, visual programming itself.

https://en.wikipedia.org/wiki/Sketchpad

Ivan Sutherland Sketchpad Demo 1963:

https://www.youtube.com/watch?v=6orsmFndx_o

>This video is a TV show made about the software Ivan Sutherland developed in his 1963 thesis at MIT's Lincoln Labs, "Sketchpad, A Man-Machine Graphical Communication System", described as one of the most influential computer programs ever written. This work was seminal in Human-Computer Interaction, Graphics and Graphical User Interfaces (GUIs), Computer Aided Design (CAD), and contraint/object-oriented programming. While watching this video, remember that the TX-2 computer (built circa 1958) on which the software ran was built from discrete transistors (not integrated circuits -it was room-sized) and contained just 64K of 36-bit words (~272k bytes).

Nicholas Jackiw's "The Geometer's Sketchpad" (GSP) is considered a Visual Programming Language (VPL) within the context of educational technology and mathematics due to its innovative approach to geometry, algebra, and calculus through direct manipulation and visualization. While not a VPL in the traditional sense of software development or general-purpose programming, GSP embodies key aspects of visual programming that make it a powerful tool for learning and exploration in mathematics.

https://en.wikipedia.org/wiki/The_Geometer%27s_Sketchpad

Macro Recorders (i.e. Emacs keyboard macros, Photoshop actions, etc): Many applications allow users to record a series of actions (like formatting text or organizing data) as macros. You demonstrate the desired actions, and it records your actions as executable steps. The "code" behind these macros is often generated automatically and can be edited textually, but the initial programming is done visually through demonstration.

Interactive Data Analysis Tools (like Tableau, Microsoft Power BI, etc): Some data analysis tools let users manipulate data sets visually (e.g., through drag-and-drop interfaces for selecting data ranges or specifying graph types), and then automatically generate the scripts or queries that represent these actions. This approach allows users to "program" data transformations and visualizations without writing code directly.

Graphical User Interface Builders (like XCode, etc): GUI builders, often found in integrated development environments (IDEs), allow developers to design interfaces by arranging components visually. Properties and event handlers can be assigned through demonstrations or interactions with the interface, such as by selecting elements and setting their characteristics through property windows. The underlying code for the GUI is generated by the tool, based on the visual design.

End-User Development Tools: Platforms designed to creating custom applications or automations through demonstration. For instance, tools like IFTTT (If This Then That) or Zapier allow users to create "applets" or "zaps" by choosing triggers and actions from a list of services and configuring them without seeing any traditional programming code. The logic is entirely defined through the visual assembly of components.

AgentSheets is a visual programming environment that allows users, including those with little to no programming experience, to create their own simulations, games, and interactive stories. It is particularly known for its use in educational settings to teach computational thinking and programming concepts.

Programming by Example in AgentSheets: The environment supports a PBE approach through its "Visual AgenTalk" programming language. Users can specify the behavior of agents (the active components in their simulations or games) by defining rules in a visual manner. These rules are often created by demonstrating actions or setting up conditions and outcomes using a graphical interface, which the system then translates into executable logic.

https://agentsheets.com/

https://edutechwiki.unige.ch/en/AgentSheets

David Ackley's "SPLAT" programming language for the Moveable Feast Machine, and Lu Wilson's "Sandpond" visual cellular automata programming language, let you define rules by example, which I recently wrote about on HN here:

https://news.ycombinator.com/item?id=39632735