Ivan Sutherland Sketchpad Demo 1963

Demo of Ivan Sutherland's 1963 Sketchpad: ▶ this video It was a drawing app with the following features: Snap to object ("This allows me to be sloppy while I'm drawing and get a precision drawing at the same time"), connected vectors, arcs, alignment with other objects, copying, multiple "files," scaling ("It scales approximately 2 miles in size"), 3D, etc etc It blows me away that this kind of UI was even conceived in the 1960s. It feels like there was a dark ages middle period after then until quite recently.

TL;DR: If you share the sentiment of the parent commentator you may find this wall of text interesting. You might be interested in Alan Kay's "Doing with Images Makes Symbols Pt 1", link (46:29). This video features excerpts from Ivan Sutherland's Sketchpad demo ( link , 10:34; ▶ this video , 19:19) and Douglas Englebart's seminal demonstration ( link , 34:45). I recommend watching all the videos in full to get a proper sense of context (Alan Kay's excerpts from Douglas's demonstration particularly don't include the bits that explain how the workstation's camera system works, which is important; also, the right audio channel in the Alan Kay video unfortunately seems to be dead, while the other videos are much better). Highlights from Alan Kay's video include (in hi..low precedence) info about the Sketchpad's CPU, which you might want to listen to twice so you don't mishear (8:58), some really depressing acknowledgements (from Alan Kay himself) that Sketchpad was a never-reproduced gem even in the 80s (8:33), Ivan's (quoted) remarks on the features of the Sketchpad system (7:58), and acknowledgement about the lack of ease of use of light pens (7:12). I consider the above videos to be my own personal pinnacle, what I look up to when I think about good computer design. Some may find them depressing for the reasons you've outlined. It's sad that this obscure niche of computing doesn't lend itself to being very actionable in this day and age. There's definitely no comparison in t

I don't know if it's selection/survivor bias, but every time I watch a video about computers from the 60s and 70s, I am amazed how spot on they are with the trajectory of the technology. Take this CAD demo from MIT back in 1963 showing features that I commonly use today: ▶ this video Then the 80s and 90s rolled in, the concept is computers that entered the mainstream. Imagination got too wild with movies like Electric Dreams (1984). Videos like this make me think that our predictions of AI super intelligence are probably pretty accurate. But just like this machine, in actuality it may look different.

I remember reading an article on Source Code In Database back in the early 2000s, and it's been knocking around my brain ever since as something I ponder every couple of years. I just can't shake the feeling that there's the gem of a future paradigm where everyone wonders "why we didn't always do it that way?", but then every time I try to follow those thoughts through to a conclusion, it always feels like it'd just be re-implementing Smalltalk, and then the question is "why isn't Smalltalk more popular?" That said, there's a lot to be said for revisiting old ideas. There was so much interesting research done in the 60s and 70s in all sorts of random directions, maybe because at that time there were no precedents or expectations for how things should be done. There are so many untapped resources here, it's crazy. Every now and then I re-watch "The Mother of All Demos" [1] from 1968 where Douglas Englebert demonstrates some of the research at Stanford or the Sketchpad Demo [2] from 1963 where Ivan Sutherland is presenting a GUI-based CAD system. Fortunately, these ideas have now been picked up again, but to me it's interesting to note just how long a time lapsed between these ideas and becoming mainstream. Some of it is obviously the cost as the state-of-the-art research machines were massively more powerful than the home computers even 2 decades later, but I'm sure there were a lot of great ideas that have just been forgotten. Part of the problem, I think, is that we have fou

Here are 2 that he often brings up: Ivan Sutherland's Sketchpad demo - Object oriented graphics using a constraint based system ( ▶ this video ) Douglas Englebart's demo - too many innovations to list, but includes real time collaboration (he demoed in a convention center while the system ran 30 miles away in his lab, connected by a leased line operating at 1200 baud!). People think he just invented the mouse, but the overarching theme in his work was augmenting human capabilities... link

The first demonstrator here is Timothy E. Johnson, not Ivan Sutherland. Johnson did the "Sketchpad III" work extending Sketchpad into 3D which is demonstrated from 11:30 ▶ this video . Then Larry Roberts appears to demonstrate his own work on hidden-line removal, which is shown from 14:42 ▶ this video . See link for more video, including appearances by Sutherland himself. link is an active effort to get Sketchpad running again on a new TX-2 emulator.

John Von Neumann famously questioned the value of compilers. Eventually we get the keyboard kids that have dominated computing since the early 70's in some form or another whether in a forward thinking way like Dan Ingalls or in an idealic way like the gcc/Free Software crowd. In parallel to this you have people like Laurel, Sutherland, Nelson who live in lateral thinking land. The real issue is that we've been in-store for a big paradigm shift in how we interact with computers for decades at this point. SketchPad let us do competent, constraints based mathematics with images. Video games and the Logo language demonstrate the potential for programming using, "kinetics." In the future we won't code with symbols we'll dance our intent into and through the machine. ▶ this video link link

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

The "Visual" in "Visual Programming Language" is about the graphical, interactive method of creating and understanding programs, rather than merely the visibility of textual or graphical code. Spreadsheets typically show the entire formula of the selected cell at the top of the window, at the full width of the window. Visual programming languages based on outliners and notebooks, like UserLand Frontier, Jupyter, or Mathematica, let you hide the code by closing the outlines or code editor views. The many lives of Frontier: link Demo of Scripts menu in Little Outliner: link Ivan Sutherland's pioneering PhD thesis "Sketchpad" didn't show code or formulas or constraints on the screen all the time either, focusing on the graphical content itself that you were creating and editing and programming with direct manipulation, demonstration, and constraints, instead of just the code. Ivan Sutherland Sketchpad Demo 1963: ▶ this video >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

People always seem to forget that Xerox borrowed a lot of ideas themselves. Douglas Englebart at Stanford Research Institute gets credit for many innovations, including the mouse. The infamous "mother of all demos" can be seen here: link Going back to the early 60's, there was an equally famous GUI demonstration at MIT, using a light pen instead of a mouse as a user input device for rudimentary CAD. ▶ this video Finally, anybody who claims that the Mac or Windows was nothing but a copy of the Alto has never seen an Alto in action. link

From hn.algolia.com: link --- In Inkscape (Illustrator, Draw, ...): link --- For tracing there are many tools as well, e.g. FlexiSIGN, link --- For a use case, see Ivan Sutherland's Sketchpad Demo: ▶ this video

There is more to visual programming than simple wire diagrams and "code-blocks-as-visual-blocks": ▶ this video link link link And yes, this: link This is not 100% real programming, because it does not include sensors, but you do create constructs that interact with the environment and accomplish goals. It's close enough to show what's possible with certain interfaces. Long-term: link There have been much fewer resources allocated to the development of these concepts. Mostly for historic reasons. The sad reality is that both critics and proponents of visual programming are often uninformed about prior work, user studies and related research rooted in cognitive and developmental psychology.