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?
This was '93-95. The majority of the computers were monochrome Macs, but his instructor machine was a color computer. We did Hypercard, and other bits I've since forgotten.
What I can remember is buying tons of floppies (which I might still have - I did a couple years ago) and staying after school to play Bolo. With his color computer, and practice, he kicked the rest of our butts in the game. Floppies were to store the 'Brains' that we got off the internet, as well as maps we had made, or that we got online.
I know for me that initial foray into computers, something we wouldn't have in our house until late high school, lead to me working on web sites late at night (AOL's HTML documentation being how I learned basic HTML), which lead me to not taking any computer classes in college, but still ending up as a web developer by trade (15+ years professionally).
High school was definitely a difference experience; DOS machines at the time, with Apples being in a different room later, that were taught primarily as word processors.
Unlike middle school, I believe we got in trouble when we tried to play games (Hexen being one of them) after class.
I remember downloading maps and whatnot for it over Gopher, with my 1200 baud modem. Good times.
The class was very rigid, giving us instructions on what to do.
However, a few of us deviated from the rules and enjoyed learning on our own, finishing the assignments quicker just so we could try out new things.
Of course we got in trouble in class, but many of these same students got into trouble in other classes. (I tended to ask too many questions, I believe I was told.)
Between these 2 books, which one would you recommend as research?
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... They also have Teach Yourself HyperCard (1989) https://archive.org/details/TeachYourselfHyperCardforAppleMa...
Vipercard is an open source re-creation https://news.ycombinator.com/item?id=16675180
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!
I couldn't agree more with this conception, and I wish that philosophy was more widespread within our industry. Sadly, it seem that the predominant philosophy is the opposite: users are mere consumers, cattle really, who should be grateful their programmer masters deign to provide them anything.
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.
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? :-)
HyperCard demonstrated that a teacher could create software for their own personal use.
I'm unaware that this is possible with iOS (for example).
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.
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) 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.
Hypercard was really the gateway drug to programming, like web/JS is today.
HyperCard let you prototype the exact same thing in a matter of seconds.
(I had missed these previous discussions and I’m a fairly regular HN reader.)