
Sketchpad III Demo [video] (1963) - ShaneWilton
https://www.youtube.com/watch?v=USyoT_Ha_bA
======
Animats
Sutherland saw, very early, that a constraint system was the way to go. We
went through generations of CAD systems and draw programs which didn't do
constraints. Even today, most draw programs don't do constraints as well as
Sketchpad.

Sketch mode in Autodesk Inventor does constraints very well, including
difficult geometry problems like circles tangent to other circles. This is a
solved problem today, but tends to be solved right only in the better CAD
systems.

(If only the HTML people had thought in terms of constraints. Left edge of box
B is coincident with right edge of box A. Right edge of box B is coincident
with right edge of window. Left edge of box A is coincident with left edge of
window. Top edge of box A and top edge of box B are collinear. Boxes A and B
have equal width. That's the way to get two columns.

Unlike CSS layout, this concept can be extended beyond rectangular boxes;
constraints with circles and splines are usually solveable.)

~~~
melloclello
As I remember, an early CSS proposal included the Cassowary constraints solver
engine, but they decided not to go with it because either a fast
implementation didn't exist at the time, or they were worried users wouldn't
find the system intuitive?

~~~
azeirah
I remember that the Cassowary constraint system was implemented in Apple's app
development framework, and people reporting that it was hell to work with
after building anything beyond minimal complexity.

Also, there is an actual GSS implementation by thegrid.io

[https://gridstylesheets.org/](https://gridstylesheets.org/)

~~~
Sidnicious
I've worked with Auto Layout a bit.

\- The GUI built into Xcode is usable once you learn its quirks (e.g. how to
swap the relationship in a constraint so that it doesn't say that the right
edge of some button needs to be -5pt from the left edge of the button next to
it).

\- The ObjC/Swift API is bad.

\- It handles RTL languages excellently: by default, constraints are expressed
in terms of leading/trailing edges, but can be literal left/right if you want.

\- It deals poorly with adding and removing views from a hierarchy: removing a
view discards all of its constraints, so you need to have logic to reestablish
them.

Unfortunately, there are horror stories about performance tanking with an OS
update or taking on exponential properties, like this one which lead the team
to develop a non-constraint-based layout framework:

[https://realm.io/news/slug-nick-snyder-
layoutkit/](https://realm.io/news/slug-nick-snyder-layoutkit/)

It leads me to wonder if unpredictable performance is a limitation of
constraint solving… or at least to be cautious with current implementations.
Maybe an API that only makes known-fast relationships possible would help.

------
riffraff
obligatory quote, for those who have not read it before

> When asked, "How could you possibly have done the first interactive graphics
> program,

> the first non-procedural programming language, the first object oriented
> software system,

> all in one year?"

> Ivan replied: "Well, I didn't know it was hard."

------
i336_
Ah, SketchPad. You put [http://catb.org/jargon/html/story-of-
mel.html](http://catb.org/jargon/html/story-of-mel.html) to shame.

The [https://en.wikipedia.org/wiki/TX-2](https://en.wikipedia.org/wiki/TX-2),
the machine SketchPad ran on, had 460KB of 36-bit memory, _and it. ran. at.
400kHz_ \- yes - 400k instructions per second.

The CAD system that introduced the idea of the GUI, clipboard, OOP, and so
many other things, ran only a little faster than the masked-ROM calculators
you can buy for a couple dollars at the store down the road nowadays. It's
kind of depressing.

If you liked the OP video, you _must_ watch
[https://archive.org/details/AlanKeyD1987](https://archive.org/details/AlanKeyD1987).
It's only 46:29 long.

I really, _REALLY_ want the SketchPad program. If I had a bunch of money
tucked away I would easily dedicate a decade of my life to trying to track it
down.

As an aside, I'm not quite sure how to refer to the amount of memory it has,
particularly considering that the memory is 36-bit and not 8-bit. Wikipedia
says it has 64KB; the video says (I quote) "460 K bytes".

References:

\- I waxed philosophical about SketchPad a few months ago:
[https://news.ycombinator.com/item?id=13102757](https://news.ycombinator.com/item?id=13102757)
(article:
[https://news.ycombinator.com/item?id=13097121](https://news.ycombinator.com/item?id=13097121))

\- [http://bitsavers.trailing-
edge.com/pdf/mit/tx-2/](http://bitsavers.trailing-edge.com/pdf/mit/tx-2/)

------
az123zaz
Professor: "We're going to show you a man actually talking to a computer.."
Interviewer: "Surely not with his voice."

~~~
hotcrossbun
The chat with the professor is one of my favourite parts. Paraphrasing.....At
the start he may not know what the problem is, but through interaction and
response, he and the computer will work it out together. Totally nails
interactive design, and what software development is, and yet often still
fails to be

------
pliptvo
More precisely, what's being demoed is Sketchpad III, which improved
Sutherland's original 2d Sketchpad with 3d rendering capabilities. And Ivan
Sutherland's not in the video.

~~~
dang
Ok, we updated the title above to reflect that. I confess I thought it was
Ivan :(

------
melling
Douglas Englebart's video is another classic video that took place in 1968:

[https://youtu.be/yJDv-zdhzMY](https://youtu.be/yJDv-zdhzMY)

Light pen's and chorded keyboards in the 1960's.

