Sketchpad: A man-machine graphical communication system (1963) [pdf] | Hacker News Reader

Sketchpad: A man-machine graphical communication system (1963) [pdf]

cl.cam.ac.uk

116 pointseternalban26 comments

Open articleView on HN

Sketchpad demo on Youtube:

https://www.youtube.com/watch?v=USyoT_Ha_bA (part 1)

https://www.youtube.com/watch?v=BKM3CmRqK2o (part 2)

Truly mind blowing! Thank you for sharing this great videos.

Just 45 seconds into Part 1... inside Lincoln Labratory;

“John, we’re going to show you... a man actually talking to a computer. In a way, far different than it’s ever been possible to do before.”

“Surely, not with his voice?!”

“No, he’s going to be taking graphically.”

I almost fell off my chair. You really have to hear it to appreciate how ridiculous the reporter thought that would be.

So wonderful. It just gets better from there. Great link, thank you!

I saw a stage production of this demo a few years ago. IIRC it was on the Stanford campus and was titled, simply, The Demo.

It was neat. Strange, but neat.

Here we are: https://nytimes.com/2015/03/26/arts/music/the-musical-the-de...

It was a musical, not a play. Though not the typical musical one thinks of. I sat behind Jaron Lanier.

(It’s too late to edit my previous comment.)

It's not the same demo, the article is referring to "The Mother Of All Demos" [1].

[1] https://www.youtube.com/watch?v=yJDv-zdhzMY

Whoops, you’re right. Thanks for the correction.

I finally finished reading this dissertation for the first time a few weeks ago. It's astounding that in 1963, on a computer built in 1959, Sutherland wrote a graphical user interface for a constraint-satisfaction-based CAD system with (what Ted Nelson would later dub) transclusion, using object-oriented programming and accelerating his graphics with SIMD arithmetic. (An appendix contains a proposal for a GPU — but it's really just a 2-D accelerator to offload the drawing of lines and circles from the CPU. Five years later, Sutherland wrote a paper on the "Wheel of Reincarnation" about how GPUs tend to become full-fledged CPUs, starting the cycle again.)

It won't surprise anyone who read http://canonical.org/~kragen/memory-models/ that the most interesting part to me was the way Sutherland uses memory — he calls out his use of structs (he calls them "blocks" or "n-component elements") as a departure from the tradition of arrays ("tables"), but for me the more interesting part is how his use of them differs from the directed-graph memory model we use almost universally nowadays. (See p.37, "N-component elements", for his introduction to structs.) Rather than simply using single pointers, the participants in each many-to-one relationship are linked together into a doubly-linked list ("ring") with its head ("hen" (!)) in the item on the "one" side of the relationship, and the list nodes ("chickens") in the items on the "many" side. This means you can efficiently traverse the relationships in either direction, which considerably simplifies the implementation of the Observer pattern.

Literally every GUI program is based on SKETCHPAD. Sometimes Alan Kay gives Sutherland credit for inventing object-orientation, although Smalltalk and Simula clearly contain some ideas that aren't in SKETCHPAD.

If you liked SKETCHPAD you'll probably love GENESYS, which demonstrates Bret Victor’s acting-out-based animation interface on a tablet — on the TX-2 in 1969: https://www.youtube.com/watch?v=GYIPKLxoTcQ

Check out the awesome tool "The Geometer's Sketchpad", inspired by and named after Ivan Sutherland's 1963 SKETCHPAD program.

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

>The Geometer's Sketchpad is a commercial interactive geometry software program for exploring Euclidean geometry, algebra, calculus, and other areas of mathematics. It was created by Nicholas Jackiw for the Visual Geometry Project at Swarthmore College. It is designed to run on Windows 95 or Windows NT 4.0 or later and Mac OS 8.6 or later (including Mac OS X). It also runs on Linux under Wine with a few bugs.

http://www.dynamicgeometry.com/General_Resources/The_Sketchp...

>The Sketchpad Story

>The origins of The Geometer's Sketchpad date back to the 1980s and to the Visual Geometry Project, a research project at Swarthmore College under the direction of Drs. Eugene Klotz and Doris Schattschneider. This project, funded by the National Science Foundation, aimed to develop new technology-based materials for use in the teaching of geometry. Under its umbrella, Nicholas Jackiw pioneered the development of the first version of The Geometer's Sketchpad. The program's name honors Ivan Sutherland's 1963 SKETCHPAD program, a groundbreaking early work in interactive computer graphics (Sutherland, 1963).

Geometer's Sketchpad Tutorial: https://www.youtube.com/watch?v=EP-AkvJtMWU

Short Video Showing What's New in The Geometer's Sketchpad® 5: https://www.youtube.com/watch?v=JT70rqQ0I-8

Geometer's Sketchpad: Demonstration: https://www.youtube.com/watch?v=FqjWBeR_nqQ

This remains my favorite software ever written. It's so simple but you can do so much with it. You can end up "rediscovering" bezier curves, ellipses, and parabolas as loci of various forms. It's really something else. Well worth a couple bucks a year for my license.

Damn, wish I'd known about that project when it was going on: I had Klotz in a couple courses back in the '60s.

It's worth noting that Ivan Sutherland is still alive and doing research, although now on asynchronous circuits [1] instead of computer graphics.

Edit: that's not how links work on HN apparently

[1] http://arc.cecs.pdx.edu/

I wish we had a Sketchpad-style CAD interface on the reMarkable tablet. It could be the 'real' dynabook.

The tools exist with which to do it. People have reverse-engineered the reMarkable enough to start creating Rust libraries to support the hardware[1].

I've been thinking of experimenting with building a Sketchpad-like system on it. With Rust, you have access to LLVM fairly easily, so you could probably do something with JIT compiling code (maybe a Smalltalk dialect) to give whatever you build a programmable interface.

Why Smalltalk? It's simple syntax would be easier to deal with on the reMarkable, and you might be able to look at doing handwriting recognition to let you write the code with the stylus. Could also go with a Lisp, for similar reasons.

All of this is just speculation because I haven't started it for lack of time, but I'm really interested in exploring what's possible in that space. The system specs will probably be constraining (I haven't looked at them recently) but I'm sure they're far far more than what Sketchpad had.

[1]: https://github.com/canselcik/libremarkable

I've been eyeing the Remarkable up for some time now. This lib looks pretty cool. Anyone here using this device that could share opinions on its quality and utility?

I use the device (unmodified) very regularly. It's fantastic, highly recommended. The only problem is the price tag.

I came to it from the perspective of wanting a digital notebook that I could also load PDFs on and write margin notes in. I used to keep handwritten notes in notebooks, mostly bullet journal style, and I've completely converted over to using the reMarkable for that.

For that purpose, it is excellent. The software has a few bugs that I've bumped into from time to time, but nothing show stopping. The feel of the stylus on the screen is much closer to pen and paper than anything else I've tried.

It's running Linux and you can shell into it when it's connected to a computer via USB (it appears as a network device on the host), so even if the company collapses, it's very hackable as evidenced by the library I mentioned above.

That said, the price point is a bit high for what it does, and the first thing I always get asked about it is whether it converts my writing to text, which it doesn't.

My wife is in grad school and used to print out papers she needed to read for class so she could write margin notes, and now she just loads the PDFs on her reMarkable and keeps notes there.

The EPUB support was dodgy last time I tried it. The one book I loaded on it would only show one line per page until I adjusted the font size. I generally prefer PDF format anyway, since it's usually laid out better and I'm usually reading technical books on it anyway.

All that said, I highly recommend it, if it's something you think you'd find useful, and aren't put off by the price tag.

I’m unfamiliar with the reMarkable tablet. How would what you describe be different than the same but on a tablet or tablet PC?

A classic.

Do not miss the "Chickens and Hens" data structure. (I am still trying to understand the analogy since they both lay eggs! :) It is a doubly linked-list with some extra sauce.

Bret Victor has a great talk called "The Future of Programming" where he discusses Sketchpad and other work in computer science that was done before 1973 but still feels fresh and relevant today.

http://worrydream.com/dbx/

Always wonderful and still inspiring.

Alan Kay's talk referencing it is now also 30 years old:

https://www.youtube.com/watch?v=6ZdxiQoOBgs&t=251s

I also wrote a little piece a while ago relating Sketchpad and constraint programming to things like bindings and FRP:

http://blog.metaobject.com/2014/03/the-siren-call-of-kvo-and...

Alas, it seems we haven't been able to locate the source or binary for this important artifact. It would have been wonderful to have this preserved and a simulator, like we have for the Alto and countless IBM machines, etc.

Failing that, I'd be happy to just have a reimplementation, that's a faithful as possible to the original.

As far as I know, that's correct. Furthermore, the TX-2 it ran on was a one-off machine, and was changed over time, so the same instruction might do different things before and after hardware changes. I don't know of a description of the TX-2 at any point in time sufficiently complete to write a simulator, much less at the particular time SKETCHPAD was being built.

Presumably it would be somewhat simpler than the PDP-1 simulator, and perhaps could even use the same scope simulation code — Norbert Landsteiner tells me that simulating the visual effects of the scope tube was the hardest part of writing the PDP-1 simulator.

Sketchpad listing at the Computer History Museum:

http://www.computerhistory.org/collections/catalog/102726903

Oh cool, thanks for pointing that out. It looks like it would be a major undertaking making a working piece of code from that.

And here I am upset that the word booby only appears twice in the paper.

Reply on news.ycombinator.com