
HyperCard Users Guide (1987) [pdf] - tablet
https://vintageapple.org/macprogramming/pdf/HyperCard_Users_Guide_1987.pdf
======
adamrezich
I'll never forget learning basic HyperCard usage in Computer Class in seventh
grade... in 2005. My public middle school had just got brand new shiny white
iMacs... which they used exclusively to run the Classic Mac (or whatever it
was called) emulator, so we could learn HyperCard and use some ancient
monochrome typing tutor.

I was always annoyed that "Computer Class" was taught like this--having
students follow step-by-step instructions to the letter to "learn" how to use
ancient software with almost zero room for creativity or exploration. Trying
to "color outside the lines" and use any of these tools for anything other
than the explicit purpose of the curriculum was forbidden. I remember
recognizing that HyperCard seemed like an old cross between HTML and
PowerPoint, and I really wanted to try making a game with it... but my teacher
wouldn't allow it. "Computer Class" basically always felt like we were being
rigidly instructed how to do the menial white-collar office work of a decade
prior, instead of allowing us to unlock our creativity and explore all the
cool stuff this fancy new technology could actually do.

I often got the vibe that these teachers really didn't know how to do
literally anything with the computers they were teaching us to use, outside of
exactly what they were teaching us how to do... and they were afraid that we'd
figure out how to use the computers better than them.

What do kids in middle-class public middle schools learn in "Computer Class"
these days? Is it still just typing, basic Office use, and HTML4? What's a
"Computer Class" like now that everyone carries one around in their pocket at
all times?

~~~
protomyth
From what I've seen lately, Computer Class is just the place where you do your
homework or gone entirely because they have some laptop / tablet in the
classroom. Computer Programming went the way of Shop classes, probably for a
very similar reason. You need a teacher that if competent can make more money
elsewhere and you need a dedicated room. From a school's eyes computer
programming is logistically a vocational class.

~~~
scarface74
Which is sad. A few years ago there was a push to bring “programming into
schools”. I thought this was weird. We had AppleSoft Basic programming courses
in 1988 when I was in 8th grade (magnet school) and at my regular old run of
the mill public high school up until 1992.

------
kalleboo
The HyperCard Users Guide was good, but it was after my uncle loaned me his
copies of "The Complete Hypercard Handbook"[0] and "HyperTalk 2.0 The Book"
that I really got obsessed. I was 9 years old and reading these thick tomes
cover to cover, and building test stacks for each obscure function. The code
examples were full of jokes that were way over my head but I loved it
nontheless (or maybe that's part of why I did love it).

[https://archive.org/details/The_Complete_HyperCard_Handbook](https://archive.org/details/The_Complete_HyperCard_Handbook)

~~~
treve
I'm very interested in Hypercard and digging up some of these old ideas (and
perhaps applying them to the web?)

Between these 2 books, which one would you recommend as research?

------
sp332
Posted recently: HyperCard Adventures, a a way to run HyperCard in your
browser on an emulated Macintosh.
[https://news.ycombinator.com/item?id=19237052](https://news.ycombinator.com/item?id=19237052)

Archive.org has similar tech that lets you browse a bunch of old HyperCard
stacks. [https://blog.archive.org/2017/08/11/hypercard-on-the-
archive...](https://blog.archive.org/2017/08/11/hypercard-on-the-archive-
celebrating-30-years-of-hypercard/) They also have Teach Yourself HyperCard
(1989)
[https://archive.org/details/TeachYourselfHyperCardforAppleMa...](https://archive.org/details/TeachYourselfHyperCardforAppleMacintosh/page/n1)

Vipercard is an open source re-creation
[https://news.ycombinator.com/item?id=16675180](https://news.ycombinator.com/item?id=16675180)

------
talkingtab
Here is a question that I don't have an answer to: why was HyperCard so good?
In simple terms you could say it opened a door to a new set of possibilities,
that it was the precursor to the internet, etc. But I can't escape the sense
that HyperCard demonstrated the potential for things that have not been
realized. Anyone else have that sense, that somethings have been lost in what
we have now?

~~~
scroot
Hypercard was a thrust in the direction of the Engelbart/Kay/Papert vision of
personal computing, one where there wasn't so much of a division between
"programmers" and "users" (Hypercard users were even called "authors"!) This
vision of computing has fallen out of fashion for a few reasons, and it's a
real shame. We have, instead, allowed our personal media to become arcane
devices of dubiously "necessary" complexity. You can see this in any cafe
where a web developer is using a teletype emulator to create a UI, or when
someone cannot take the logical "next step" in processing some information in
their spreadsheets (like retrieving data easily) because the system is not set
up to allow them to explore that possibility without first learning a full
fledged programming language top to bottom.

One lesson from this Kay/Papert line is that, when it comes to personal
computing systems, metaphor is key. Hypercard worked in large part because the
metaphor of cards, stacks, and live objects acting on cards and stacks was
highly intuitive to a lot of people. Add in the fact that you "do Hypercard"
in Hypercard itself, and that the home stack is itself an explorable example
of how the whole system works. Imagine if web developers could work this way,
making their sites and applications in the browser. Good luck copying and
pasting that button!

~~~
talkingtab
Lots of good thoughts! I ended up at constructionism:
[https://en.wikipedia.org/wiki/Constructionism_(learning_theo...](https://en.wikipedia.org/wiki/Constructionism_\(learning_theory\))
and wonder if perhaps that is a key concept? The points about metaphor,
authoring and others in your reply are significant as well. As a
contstructionist, my next question is how to build a modern hypercard? What
would that look like?

~~~
scroot
Constructionism seems to be one of Kay's sticking points -- this is one of the
ways children can learn best (but what about adults?)

Obviously a modern Hypercard cannot simply be a contemporary reimplementation
of Hypercard, with extended APIs for the online world etc. That, in fact,
exists and it's called Livecode.

What was great about the later versions of Hypercard is how they fit
holistically within OS8/9\. You could interface with Applescript and access
key APIs in the rest of the operating system in the plain way. What really
should have happened next is that many of the basic applications should have
themselves been implemented in "a hypercard" For example, imagine a Finder
that let you peek under the hood to see all of its scripts and, after some
kind of "unlocking" allowed you to change it. You get access to a lot of the
power of the OS's API for free at that point, and users can easily figure out
how to script something like a "every three days move files from here to
there" or something.

The switch to Unix also meant a switch to and older, more complicated, less
intuitive bundle of methods for system scripting. Useful UI metaphors go away
at that level and are replaced with bad and outdated metaphors, like the
teletype. Leaving aside things like Applescript which have been largely left
to die on the vine, personal computing operating systems seem to have
regressed from the contructionist perspective.

I guess what I'm suggesting is that you cannot have a "modern hypercard"
without having a different kind of operating system, which itself might
require a different hardware architecture.

An ideal system would be "layered." For example, at Layer 1 you have "a
hypercard" and most of the GUI, including Finder-like things, windows, basic
buttons, can be manipulated easily at this level. Users can also peek. But one
they reach the limits of that high level hypercard system, then can "peel
back" a layer and are introduced to lower level APIs and a new language. It
has access to all the same objects and APIs as the hypercard layer, but in a
different way, along with more APIs that were previously invisible. You could
then have a third layer that is the systems language and APIs at the lowest
user accessible level -- this is where "professionals" would live, but because
it would be exporable and "peel back-able," determined users could get there
by example.

Something like a lisp machine at layer 3 that runs a smalltalk at layer 2 that
runs "a hypercard" at layer 1 would fit the bill. But take those as analogies.

~~~
talkingtab
I've come to a variant definition of constructionism, based not as a way to
learn, but construction as a way to explore/understand. Especially when being
entrepreneurial, analysis only takes you so far. In one of the YC video things
someone said something to the effect that in Silicon Valley more people tend
to talk about "what if you could?" rather than "why you can't", which sums it
up for me.

The best example of a constructionist approach I can think of is complex
adaptive systems (CAS)- the way to understand a CAS is to build one, taking
one apart only gets you so far.

I see where you are going about the lisp and I like that! What a cool idea!
lispercard? :-)

------
dasil003
I was 9 years old in 1987 when my dad bought the first family computer: a
Macintosh SE. HyperCard immediately captured my imagination and I remember
spending many long hours working on my stacks and pouring over this very
guide, and pining for the critical second half of the documention the
_HyperCard Script Language Guide_.

It's hard to describe how out of reach basic documentation seemed to a child
at the time compared to today where anything you want to learn about
programming is readily available for free to anyone with an internet
connection.

~~~
plushpuffin
I didn't have any programming books when I was 12, so I learned entirely by
reading the source code of other people's stacks. For a little while I thought
all variables had to be named box1, box2, etc, because one of the stacks I
played with was a kind of mad libs game and all of its variables followed that
convention. Finding out that I could name variables whatever I wanted was a
revelation.

------
scarface74
There is a direct line from HyperCard to where I am now.

I started programming as a hobbyist on the Apple //e in BASIC and 65C02
assembly language. But, I released a much better version of Eliza written in
HyperCard
([https://en.wikipedia.org/wiki/ELIZA](https://en.wikipedia.org/wiki/ELIZA))
and submitted it on AOL and to the freeware FTP archives around 1993. It also
used an XFNC that let me use the original MacinTalk text to speech engine and
the newer PlainTalk.

A professor at another college had been looking for an Eliza HyperCard stack
to use with his HyperCard based Gopher server. He reached out to me on AOL and
that was my first paying side gig.

Having some freelance software under my belt in college at the no name school
I was attending helped me stand out and get an internship my junior year in
1995 in the much larger city where I still live.

That led to my first job when I came back a year later at the company where I
interned.

Side note: Writing the Eliza clone has been my go to “Hello World” program for
years. I’ve written versions in AppleSoft Basic that used SAM
([https://en.wikipedia.org/wiki/Software_Automatic_Mouth](https://en.wikipedia.org/wiki/Software_Automatic_Mouth)),
GW-Basic, DEC VAX DCL, VB6, C# on Windows Mobile, JavaScript, and PHP.

------
ncr100
Hypercard powered the first, afaik, multimedia yearbook, at South Eugene high
school, in Oregon, in 1991. I designed the UI. Hypercard was perfect for
pulling that photo and text data together, and we burned it onto 650MB CDROMs,
velcro'd to the inner back of each hardbound yearbook.

------
jasonpeacock
I got started with QBasic, but really it was Hypercard that showed me the
power of programming when I built a multi-media presentation that included
laser disc cut-scenes for a school project.

Hypercard was really the gateway drug to programming, like web/JS is today.

------
gglitch
I need a master list of end-user-friendly programming environments with built
in guis/tuis, like HyperCard, Tiddlywiki, maybe Jupyter.

~~~
scroot
Don't forget spreadsheets -- the most used programming environment on the
planet

------
coldcode
I used Hypercard to design UI back then, UI was primitive compared to today,
but the knowledge of how to design functional and useful UI was also very
early. Hypercard made it easy to create interactive design you could actually
interact with instead of just looking at.

~~~
joezydeco
Especially when the alternative was incredibly hard. Getting a simple UI
running on the Mac involved using their IDE, learning a ton of Pascal,
understanding the application framework, and memorizing dozens of Toolbox
calls to get elements built and displayed.

HyperCard let you prototype the exact same thing in a matter of seconds.

~~~
scroot
The alternative is _still_ incredibly hard!

------
js2
I wouldn’t normally just post a link to an HN search, but I happen to have
just searched HN for HyperCard... and well it’s definitely a favorite of HN:

[https://hn.algolia.com/?query=hypercard&sort=byPopularity&pr...](https://hn.algolia.com/?query=hypercard&sort=byPopularity&prefix&page=0&dateRange=all&type=story)

(I had missed these previous discussions and I’m a fairly regular HN reader.)

------
mosselman
Never saw this before, how cool. It makes you think about the current state of
software: the main difference is that we can do the same things as is seen
here, but in the browser. Apart from that our day-to-day software might even
be less advanced. Apps like Notion come to mind as a modern day equivalent.
The only thing is that this is more than 30 years ago!

~~~
scroot
If you have the time, grab Sheepshaver and boot up the last version of
Hypercard. You will see that it did a lot of things that a browser simply
cannot. For example, you can copy a button from anywhere and paste it into
your own stack using copy/paste. Think of what it takes to do that on the web!

------
arnmac
I loved HyperCard is got me interested in development and I spent HOURS
working on the perfect stack.

