
Why Hypercard Had to Die - uros643
http://www.loper-os.org/?p=568
======
ezy
This doesn't seem to be anything special about Hypercard.

Hypercard was the BASIC of the Macintosh in that it served the same niche. It
certainly was not BASIC, but the idea was the same, a little language and
environment that fit into the machine's environment that allowed novices (and
then highly practiced novices :-)) to create stuff on the machine for other
people to use.

It was killed for the same reason BASIC, in the sense of built-in 8bit micro
BASIC, kind of fell to the wayside except as a way to stitch existing apps
together. No one is really impressed by a calculator program anymore. Matching
the capabilities of modern software is hard nowadays. It's demotivating to
create a calculator program... that's it? Hypercard really can't match even
JS, et al. in functionality.

I remember when it started to happen in the 16bit era. Software was already
starting to get too good and too complex for a simple tool. I got an Amiga.
The Amiga had a built-in BASIC -- but no one used it. Why? Because there was
no fucking way you were going to recreate even the bouncing ball demo in
BASIC. It wasn't going to happen. Essentially, anything you created was going
to be a huge disappointment with that tool. This was not necessarily true in
the 8bit days -- but from 16bit on, you either learned assembly/C or gave up.
People can learn in that environment (and did), but the barrier was much
higher.

Lowering that barrier while coming close to the capability of "real" software
is a hard problem. Fortunately, it's coming full circle. Now that machines are
powerful enough that "real" software is being written in interpreters, JS
seems like it actually _is_ the new BASIC.

I'm not totally sold on that -- because the stack is too too baroque
(although, again, people do learn in that environment). Processing is
perilously close but not quite there because it's so domain specific. Python
comes with a lot, but doesn't fit into native environments very well. If I had
to chose, I'd say it's going to be something else over the JS/CSS/HTML stack
in the same way 8bit BASIC sat over the primitive OS at the time.

~~~
asciilifeform
_> This doesn't seem to be anything special about Hypercard._

Tell that to the thousands of otherwise non-programming people who developed
real, useful applications (some of them best-selling) in Hypercard.

 _> it's going to be something else over the JS/CSS/HTML stack_

Like building a castle on a swamp. Foundations matter: <http://www.loper-
os.org/?p=55>

~~~
joe_the_user
That rant is was quite nice... had me going for a minute.

But I'm sure it is one of many in a line of "reasons the software crisis
didn't have to happen" - riiight. The "mythical man month"? It's 'cause they
didn't _do it right_ in 1960/1970/1980/1990/2001/... If only "they" would
learn...

~~~
asciilifeform
So doing "it" right is a physical impossibility, then? Care to say why?

~~~
jodrellblank
Because 'right' is in the eye of the beholder? It's subjective.

~~~
loup-vaillant
We agree much more on what's "right" than you suggest.

Take two systems which do the same things. One does it as expected, the other
surprises you in subtle ways. One does it as specified, the other sometimes
does not. One does it quickly, the other makes you wait a bit. One fits in a
few pages of code, the other takes a whole book.

I agree that you can't tell what's right _in advance_. But it's not a matter
of preference, it's a matter of _ignorance_. In hindsight, when you see the
results, you can most of the time point out what could have produced better
results, if only you knew. You can even go meta, wondering why you didn't
knew, then try and change that in the future.

------
groby_b
Sigh. Maybe instead of ranting at your "typical software engineer", the author
should spend a moment to consider that maybe it "could be built again" - but
it never has.

So the question then turns to, why has it never been built? Is it maybe
because Hypercard (and other visual systems) become entirely unmaintainable
once we get to large-scale systems? And maybe it is because most people don't
_want_ a trivialized programming environment? They either want a full system,
or just a product?

~~~
dahjelle
> They either want a full system, or just a product.

While I think this is true at the moment, it seems that there is an
interesting question behind that, as well. Why don't more people want to
create their own software? I do think the author has an implicit point:
because, frankly, creating software stinks. Jon Skeet's talk [1] demonstrates
this admirably. I spend a shockingly large part of my time working around bugs
and leaky abstractions in other software rather than implementing my own
ideas.

I don't know if it is possible to design a system with a solid enough
abstraction that these problems don't exist. I do know that HyperCard came
unusually close, as I know several folks who made HyperCard stacks who
wouldn't imagine creating software in any typical fashion.

I hold out hope that such a useful system could be created again, one that
gives people enough flexibility to create software solutions of their own
(perhaps within a genre of software) and that is able to combat the currently-
accurate stigma of programming being "hard".

[1] [http://msmvps.com/blogs/jon_skeet/archive/2009/11/02/omg-
pon...](http://msmvps.com/blogs/jon_skeet/archive/2009/11/02/omg-ponies-aka-
humanity-epic-fail.aspx)

~~~
groby_b
Hm. I've never seen a HyperCard project that was both maintainable and of a
large-ish size. I think _that_ is where the HyperCard idea broke down -
navigating through a bunch of cards is significantly more difficult than
through a bunch of text files.

Granted, that _may_ be a question of the tools. But I do find it telling that
in the long time since the "death" of HyperCard nobody could come up with
compelling tools.

And creating software is hard because ultimately, it requires analytical
thinking. Which, by itself, is hard. Yes, the choice of tool modulates the
hardness of the problem - but the underlying issues are still hard. (Note: I
do not claim non-programmers _can't_ reason analytically. I claim the
effort/result ratio is not right for them)

It's the same reason most people buy furniture instead of building it.
Acquiring the necessary skill set is simply too much effort for the result.

~~~
dahjelle
I definitely agree that software desire requires analytical thinking. (It
certainly put a halt in my thoughts about a mass-appeal software builder: if
they don't "get" [or want to get, or whatever] Excel, they don't have a chance
for much else.)

I do think, though, that not being able to make projects of large-ish size
isn't necessarily important for a wide variety of use cases. Most of the best
apps I know of do only a very small thing—but do it very well. I think
HyperCard allow people to do small things exactly the way they wanted. Which
maybe wasn't very well, but was good enough for their needs and better than
the alternatives.

As I mentioned in my other comment [1], I wonder if the parallel is somewhat
like the UNIX command line. You probably aren't going to write a MySQL
competitor in bash. But there are a whole class of small custom tools that you
will write.

To perhaps restate my original point (and this is where perhaps we agree), the
abstractions of HyperCard eventually didn't (couldn't?) adapt. Perhaps, as you
said, because of cards. As someone else commented, also partially because of
the codebase, but also, I think, because things like color and networking and
a greater number of standard UI widgets all had to be added.

[1] <http://news.ycombinator.com/item?id=3294915>

------
phodo
I recently discovered Quartz Composer, which is included on any Mac w/ Xcode,
and I was pretty impressed by its capability. IMHO it is one of the best kept
secrets of the apple-verse.

While it is very different from Hypercard, it certainly provides a level of
artistic expression and creative freedom that the article alludes is present
in Hypercard.

When I booted up QC for the first time a few months ago, I was blown away by
its awesomeness.

And then when I further explored the vibrant community out there AND the fact
that it can be readily integrated into objective-c / cocoa, it's clear that
Apple is very much in tune with what normal people and creative people need to
express themselves on a computer. To get started, here are some links:
<http://en.wikipedia.org/wiki/Quartz_Composer> and
[http://developer.apple.com/technologies/mac/graphics-and-
ani...](http://developer.apple.com/technologies/mac/graphics-and-
animation.html) Hint: If you have Xcode installed, simply type "quartz
composer" into spotlight and begin your journey.

A final note: I seem to recall but not certain that a) QC was an acquisition
by Apple of a french company; and b) the original developer has moved on from
Apple

------
edtechdev
I was sad to see Hypercard abandoned - I learned how to program with it myself
(along with Perl & CGI apps - syntax didn't matter so much as what you could
accomplish with it). But part of the reason I think is that Steve Jobs
abandoned going primarily after the education market when he returned to Apple
- he had already been burned by it (or become disillusioned by it) at Next,
but also really Apple had already saturated the education market. He and Apple
focused on the consumer market (imacs, ipods, etc.) - the business market had
already been won by Microsoft. Microsoft also already had a more successful
end-user friendly programming/scripting environment: Visual Basic and VBA. In
case some don't know, Visual Basic was the most popular programming language
in the world until overtaken by Java. VB didn't really start to significantly
decline until more people developing business apps switched to C# and other
languages.

Microsoft also won with a more popular tool for creating visual 'stacks' or
presentations: Powerpoint. Most educators were basically using
hypercard/supercard/hyperstudio to create presentations - and Powerpoint made
it easier to do so.

Hypercard (and hypertalk) isn't dead though. Applescript is still around
(despite Apple also trying to kill it). LiveCode and other options are still
around and being updated for HTML5 & mobile platforms, as is Visual Basic, too
(nsbasic). A java port of the hypertalk language is here:
<http://code.google.com/p/openxion/>

Natural language-like interfaces aren't dead, either. Look at testing tools
like Cucumber, the google search engine, Siri, and so forth. Look at all the
DSLs out there that try to make Ruby/Javascript/etc. more like natural
languages, at least in certain contexts.

------
resnamen
HyperCard is very near and dear to my heart. When I was a kid I taught myself
how to program with Hypercard. I'm a software developer today, and despite the
crazy verbose syntax of HyperTalk, I still acquired an intuition for
programming that remains helpful, 15 years later.

I actually approached Steve Jobs about the demise of Hypercard in 1998, when I
was 15, at the Seybold SF conference. IIRC he gave a pretty dismissive
response about it, basically saying that there wouldn't be a market for it
anymore. It was pretty obvious that he didn't care about HyperCard or
HyperCard-like products anymore. That, or he didn't want punk teenagers
questioning his business strategy.

As a side note, I got my photo taken with him. When the photo was developed I
saw that I was wearing a megawatt smile (shit, I met with Steve Jobs!), and
Steve was looking distractedly at something in the corner.

------
jrmg
I think much more likely explanations than the nefarious anti-creative one
given for HyperCard's death are that, to varying degrees: Steve found all
HyperCard stacks he saw to be messy and confusing, not at all the functional
simplicity he was looking for; HyperCard was taking engineering resources
and/or money that could be better spent saving the Mac, and therefore Apple.

Apple has not, in recent years, on the Mac, been against trying to provide
simpler programming environments - look at Automator, (the now also defunct?)
AppleScript Studio, or Dashcode.

~~~
david927
Simple programming environments have a fundamental flaw: they fool you.

Let's say we have a type of perforated balsa wood that you can just snap into
pieces and glue in place. Making a dog house just went from hours to minutes!
Hurrah! So you start telling everyone that this is the new way to construct
buildings, but then as you get bigger structures, it starts to fall apart.

Simple programming environments fool you into thinking you into thinking your
projects can scale, and the result is a mess. Hypercard was fun, but it wasn't
a deep paradigm, it wasn't good syntax, and in the end, I have to say that it
was good that it died.

~~~
tree_of_item
And why does it need to be "deep"?

It's good that it died because it doesn't "scale" to the elephantine size of
software you're accustomed to?

~~~
derleth
> It's good that it died because it doesn't "scale" to the elephantine size of
> software you're accustomed to?

Does nobody else find this hilarious? I mean, the whole persecuted-Mac-fan
vibe here; it's so 1990s it's almost a time warp in itself, except this time
it's a persecuted-Classic-Mac-fan, and the main entity doing the persecution
is Apple itself.

~~~
asciilifeform
Steve Jobs demolished Apple and replaced it with Next.

------
jawngee
Umm, SuperCard still exists and is under active development. Even back in the
day it was superior to HyperCard in every way.

My guess was that HyperCard was killed because the WWW was coming. I used
SuperCard pretty heavily back in '92ish at the second college in Minnesota to
get the internet (MCAD - U of M was first). I remember the rows of NeXT boxes
they had, the only machines connected and I remember fumbling around with
building Gopher sites as well as some basic HTML hacking, as basic as it was
back then. I lost interest in HyperCard/SuperCard shortly thereafter.

But it's spirit certainly lived on in Visual Basic, Borland Delphi, Macromedia
Director and a bunch of other things. I don't know that this guy had exposure
to any of this hence the short sightedness and, in my opinion, miscalculation
of Job's motives.

~~~
asciilifeform
_> the WWW was coming._

In 1998?

 _> it's spirit certainly lived on in Visual Basic, Borland Delphi, Macromedia
Director and a bunch of other things._

I have used all of these, and beg to differ. The spirit of HyperCard was that
of _radical simplicity_ , and it does _not_ live in these systems.

~~~
jawngee
> > the WWW was coming.

> In 1998?

I built my first HTML page in '93. NCSA Mosaic was the rage in the lab.

> > it's spirit certainly lived on in Visual Basic, Borland Delphi,

> > Macromedia Director and a bunch of other things.

>

> I have used all of these, and beg to differ. The spirit of

> HyperCard was that of radical simplicity, and it does not

> live in these systems.

???

Drag and drop, double click to add script, how is that not the spirit of
HyperCard? HyperCard was the preeminent RAD development tool. Easier than
Visual Basic? Sure, but not by much. The gap between BASIC and HyperTalk is
not that great a leap. If you can't see the parallels between Macromedia
Director and HyperCard, you're being blinded by your own weird sense of what's
what - considering they both used the same basic language back then.

~~~
jawngee
> Hypercard is different from systems like Director > in what isn't there: the
> cancerous complexity.

No offense, but you're reaching for straws now. Any stack of any complexity
was just as complex as the equivalent in Director. I'm not sure what you were
doing in 96 or so, but I was making a living with Director after cutting my
teeth with some serious SuperCard action. I wrote a precursor to AIM/ICQ for
our feeble AppleTalk network with SuperCard and that was not simple at all.

I guess if you were writing simple back and forth stacks, then yes I see your
argument. But anything truly useful beyond that was just as complex as
anything else. I appreciate your romantic notions to the contrary however.

~~~
thaumaturgy
I never used Director, so I can't speak to that. And, by '96, I had graduated
from HyperCard into C and Pascal.

But: I spent a _lot_ of time in HyperCard, and I can assure you that the field
of HyperCard complexity was not limited to just "simple back and forth stacks"
or "anything truly useful beyond that". HyperCard afforded a really nice way
of gradually ramping up complexity and approaching complex-on-the-outside
problems with simple-on-the-inside code.

I doubt I could remember any of my own HyperCard projects at this point if my
life depended on it. But, I can tell you about a HyperCard project a good
friend of mine did: he called it "MusicMaker", and it came with a piano
keyboard, multiple synthesizers, and its own unique musical notation system
which allowed you to easily translate any sheet music into text which the
HyperCard stack could synthesize and play on the piano keys. It could teach
people music better than just about any other piece of software at the time.
This was not, as I recall, remarkably challenging for him, and we both had a
lot of fun with it.

I think any network-related programming is going to suck. Tricks of the Mac
Game Programming Gurus had an entire chapter devoted to it, as I recall, in
which most of the chapter could be summed up as, "OpenTransport sucks". So, I
don't think it's fair to use a networking-related program as an example of a
challenging HyperCard (or SuperCard) project.

> _I appreciate your romantic notions to the contrary however._

(edited for snark)

Please try to keep the snark to a minimum. Thanks.

~~~
jawngee
Yes, and I wrote a MIDI sequencer in Borland Delphi in about 1997 and that
wasn't particularly challenging either, in fact simpler than attempting
similar in SuperCard:
[http://www.sonicspot.com/aliendiskosystems/aliendiskosystems...](http://www.sonicspot.com/aliendiskosystems/aliendiskosystems.jpg)

The point is, people tend to gloss and shine and wax poetic about HyperCard
and it's ilk, but if it was so profoundly simple and awesome, why aren't
SuperCard and related (MetaCard or Toolbook anyone?) prominent development
platforms? Because that simplicity becomes complexity once you cross a certain
threshold.

> _Please try to keep the snark to a minimum. Thanks._

Please keep attempts at editing people's personalities at a minimum. It's how
I talk, it's how I write, I make no apologies for it.

Cheers!

~~~
jacques_chester
The technical qualities of a technology are not the sole determinant of its
success or failure.

------
soapdog
HyperCard like systems are not dead. I make my living from LiveCode (
<http://www.runrev.com> ) which is a xTalk system that is able to build
applications for Mac OS X, Windows, Linux, iOS and Android. From a single
HyperCard-like environment, I can build apps for all these platforms and reuse
the code.

LiveCode is very verbose and it may take a while for those that are already
familiar with C-like languages but it is worth it. Software is easy to
maintain and there is little space for confusion, even with few comments.

RunRev company also release a PHP-like engine, so I can create web
applications that communicate with native clients on mobile and desktop all
from a single language and environment, this is very powerful.

You should always use the best tool for your job. For my job, LiveCode fits
perfectly. I also think that xTalk languages are a wonderful introduction to
programming and people from non-technical backgrounds can learn it easily and
start creating little tools to help their specific domains. Yes, anyone can
learn programming in any language, it is just a matter of effort, I believe
LiveCode makes this effort fun and productive.

You may read this as advertisement but this is my personal opinion. I am 31
and have been using LiveCode since I was 25 or something like that. In the
meantime I got married, got my own place and am living a good life. All my
work is LiveCode related. Just telling you that so you guys don't take me for
"someone that toys with this cute language every once in a while but is not
serious".

Even if you already have your favorite language, it is worth to check out
LiveCode, just to learn what else is out there. There are beginner webinars
starting next month I think...

~~~
soapdog
oh... I forgot to tell, LiveCode can import HyperCard stacks... =)

------
toddmorey
A bit of trivia: MYST, the CD-ROM game, was first shipped for the Mac and
written entirely in HyperCard (with a few custom extensions to load the color
graphics as quickly as possible).

------
Someone
I think what killed Hypercard, in some sense, was what it made popular: like
the Amiga, it was too closely tied to its hardware.

HyperCard ran black and white windows of 512*342 pixels because that is what
the original Mac had (there was a version that did some color things, but that
was and felt like a serious bolt-on job). Moreover, all graphics where
bitmaps.

Bringing that into the 'real world' as it existed at the end of the eighties
would have taken a lot of resources, and it was not guaranteed that the end
result would still be HyperCard. For example, if one allowed resizable
windows, laymen would have to learn about layout algorithms ('is this button
50 pixels wide, or a quarter screen wide? Is it 20 pixels from the bottom, 10%
of screen height, or should its bottom border match that of that text field
over there?').

Also, at the time, there were attempts to include some Hypercard/Director-like
features to QuickTime. HyperCard was considered for that functionality, but
did not make the cut.

~~~
ayuvar
I think that versions of Hypercard past v1.0 allowed for stacks of arbitrary
window size; I know for a fact that I made up at least a few 1024x768 ones in
v2.2.

You are correct in that I don't think it supported _resizable_ windows without
the use of some XCMD though.

~~~
Someone
You are correct. Surprisingly, I even found evidence for that:
<http://support.apple.com/kb/TA31048>:

* All the cards in a given stack must be the same size, even if there are several different backgrounds in the stack.

* Smallest card size: 64 x 64 pixels

* Largest card size: 1280 x 1280 pixels.

------
Yhippa
FTA: "And if you think that XCode, Python, Processing, or the shit soup of
HTML/Javascript/CSS are any kind of substitute for HyperCard, then read this
post again."

I always hope in the back of my mind that someday there will be a way to
create a web interface as easily as you could in Hypercard.

I miss it so much.

~~~
asciilifeform
No such luck. The Web architecture _inherently sucks:_

<http://philip.greenspun.com/research/internet-haters>

~~~
groby_b
Take that article with a _large_ grain of salt. Much of it has been proven
wrong by now. ("HTML is where the Web starts and probably where it will end.")

~~~
irrumator
Take anything from loper-os with a massive grain of salt, he is a long-term
troll who has been writing these sorts of wistful but ultimately empty posts
for several years now. Calling everything and everyone stupid and bloated and
yearning for the good old days is his thing. I only mention this because some
HN readers might not be fully aware of his history.

~~~
asciilifeform
The distinction between a "troll" and an actual human with unpopular opinions
is lost on you?

You aren't the only one: <http://www.loper-os.org/?p=91>

------
makecheck
Actually has a really good example (a calculator) to show how HyperCard could
be used.

HyperCard was a big part of my junior high years. It could even be extended,
e.g. there was one add-on that allowed color graphics to be displayed and I
learned to make some simple games that way.

~~~
jodrellblank
But its not a good example.

You're sitting at a device with a numeric keypad, and a 9" screen; Replicating
the calculator interface in clickable buttons, with a textbox as simulated LCD
is a horrible misuse of the potential of a computing environment.

A screen, a keyboard and a hardware ALU. Being used to run an OS which draws
some keys and a screen, interprets mouse movements, parses and interprets
Applescript and parses text arithmetic operations, so it can pretend to be
some keys and a screen connected to a hardware ALU.

And this is hailed by our "anti-bloat" author as a great example of simplicity
which normal people love, and its limits are fine, compared to any other
system - e.g. Visual Basic 3 - which is needlessly complex.

It's almost funny, until you read his seven tenets of computing and find that
any program which encounters any error should enter a debugger, so you can fix
it and carry on. I think that would drive anyone insane.

~~~
sambeau
Have you never watched a video on your PC depute owning a perfectly
serviceable TV?

~~~
jodrellblank
Yes.

I have also loaded up an OS and browser built on a cross-platform GUI
framework and a TCP-IP stack, and used it to do a DNS lookup and send a HTTP
compliant request across a tangle of hundreds of miles of interconnected
systems to Google's servers to statistically analyse my query, run it through
around 700 servers, through an index of several billion web pages, and
thousands of years of Youtube videos, millions of pictures, hundreds of
thousands of news articles and twitter streams, ranking the results, and at
the top putting the results of my calculation "2+1" or whatever.

But then, I'm not the author with the weirdo view of 'simple'. What's your
point?

------
dahjelle
I had a sudden hypothesis after reading this thread last night. (No proof,
mind you, just an idea.) I wonder if HyperCard's success was for the same
reason as UNIX's success: a well-chosen, small set of interoperable tools that
allowed the user to do far more than the sum of their parts. And, as computing
and interfaces have become more complex, we've just tacked on complexity to
them rather than reinventing them to adapt.

For instance, UNIX's treatment of everything as a file is a great tool, but I
think there was a time where that simplified a much greater percentage of
computing than it would today. Similarly, I suspect HyperCard died because the
abstractions it was using had to be reimagined to stay competitive.

Spreadsheets (as mentioned elsewhere) are an example of a product that has
managed to stay focused on the simple set of tools, and, when features were
tacked on, they often stay out of the way instead of adding complexity to day-
to-day operations. However, I'm not sure they've aged well, but I guess they
are the best we have at the moment.

~~~
bad_user
IMHO, the Linux programming environment is a mess precisely because not
everything is a file handler - not even sockets, as even though sockets can
behave like files, there are differences. Plan9 was supposed to be the
reinvention of Unix and a lot of useful stuff was ported from Plan9 to modern-
day Linux, including the /proc filesystem which is really, really useful.

Unfortunately the UNIX philosophy is so powerful that you don't understand it
until you live and breathe UNIX. And it also doesn't scale for some use-cases,
but this philosophy is the reason why UNIX is not only alive, but the dominant
platform.

Also, HyperCard is NOT a " _small set of interoperable tools_ ". And neither
is Excel.

~~~
dahjelle
Though I haven't done any Linux programming, I can definitely see your point.
A abstraction seems only as useful as it is consistent.

You're right: HyperCard and Excel aren't a small set of interoperable tools
like UNIX is. I would argue, though, that they are close: a walled garden of
interoperable tools. Rather than guide you through steps to a specific end
(the extreme example is a wizard for, say, a mail merge), they present you
with tools you can use to get to that end. Obviously, they don't work
particularly well outside their garden, and the great advantage of adding
tools to your toolset is cumbersome at best.

I do wish I understood the UNIX philosophy better. Perhaps I'll learn more
over time.

------
timinman
I loved Hypercard and BASIC too, but this post strikes me as being a little
affected by nostalgia.

With Hypercard you could make something for someone who 1) has an Apple, 2)
Has Hypercard installed, and 3) Has the right version of Hypercard installed.

With HTML/CSS/Javascript you can make something to run almost anywhere. It's
not 'easy' but it is useful.

~~~
asciilifeform
_> With HTML/CSS/Javascript you can make something to run almost anywhere._

With gargantuan effort.

And your creation will still appear distorted in unpredictable ways to many
users.

------
timinman
Don't forget, there's Hackety Hack <http://hackety-hack.com/> and Scratch
<http://scratch.mit.edu/>, two great tools for new programmers to get their
feet wet and make something fun in the process!

------
swdunlop
There's no mystery, here. No great conspiracy -- the article has a screenshot
of the smoking gun.

<http://www.loper-os.org/wp-content/hypercard-calc/hc12.jpg>

The scripting language had a verbosity and ambiguity that only a lawyer could
love. The documentation for that language was similarly impenetrable to anyone
with a background in CS, requiring a serious commitment to trial and error to
perform operations that were trivial in BASIC.

~~~
Someone
It looks that way, but it is not that verbose. Compare:

    
    
        get name of me
        put the value of the last word of it after card field "lcd"
    

with

    
    
        it = event.target.name
        currentCard.fields["lcd"].append(it.text.asWords().last())
    

It looks verbose, and in some sense it is, but having lots of implicit state
made it a nice environment for what it was.

------
shib71
Visual Basic played a similar role for me many years ago. I've moved on since,
but at the time it was exactly what I needed. The value of a WYSIWYG GUI
editor and a simple event system to a budding developer can't be overstated.

------
iradik
I think it'd be interesting to re-write HyperCard in javascript and HTML5, as
a way to get kids interested in coding (and maybe use javascript instead of
apple script as the card language?). Not sure how difficult this would be as
I've never actually used it, only heard of it's majesty and wonder. Cool that
you can still run it on an emulator. I'll have to try it out.

------
ebbv
If the author loves HyperCard so much why doesn't he re-create it? Honestly,
it would not take that long.

The answer is because he'd rather write some link bait trashing Apple and
Steve Jobs.

And because he knows perfectly well that making HyperCard is not worth his
time.

IMHO his calculator example makes it perfectly obvious why HyperCard not only
was killed but deserved to die. Like all of Apple's languages of the time,
HyperTalk is awful. Additionally HyperCard is not particularly flexible or
elegant, nor does it produce particularly fantastic end results. It's crap.

And in a day like today where we have the web enabling people who have never
even heard of a pointer (let alone had to deal with pointer math) to write
full fledged, performant, distributed, multi-user applications, why does
anyone in their right mind spend 5 minute bemoaning the loss of HyperCard?
It's absurdity.

------
gcanyon
The code for this could have simpler/less verbose. It's been a while, but I
believe in the number buttons this would have worked:

    
    
        put the short name of me after fld "lcd"
    

and in the equals sign button:

    
    
        put the value of fld "lcd" into fld "lcd"
    

(edited to fix a missing quote)

~~~
asciilifeform
Thanks!

Also there is an extra eval (the first one is unnecessary, I think.) But I am
too lazy to revise the screenshots.

------
evolve2k
I remember making a game with hyper card when I was at school and loved that I
could visually script the buttons.

We hand drew pictures of 3D rooms and then scanned them in and put big
invisible buttons over the doors etc.

I personally think the www killed hyper card, suddenly you could do very
similar things but have them instantly shared globally.

In my mind hypercards real innovation was creating your own links which would
take you to any other card you desired, I think plain old simple HTML came
along and killed the poor thing. HyperCard lived in a time of share it on a
disc and I imagine Jobs seeing it's days as numbered.

~~~
dahjelle
Bill Atkinson, the creator of Hypercard, is on record [1] wishing he'd had the
foresight to extend the links to the network. Hypercard was inches away from
being the first "web browser".

[1]
[http://www.wired.com/gadgets/mac/commentary/cultofmac/2002/0...](http://www.wired.com/gadgets/mac/commentary/cultofmac/2002/08/54370)

------
RexRollman
Hypercard was very interesting to me, enough so that I bought my first
programming book, Danny Goodman's The Complete Hypercard Handbook. I loved
tinkering about with Hypercard on my very first computer, a Powerbook 100 that
I bought new in 1992.

I was sad when Apple decided to only include Hypercard Player with new Macs,
which I also think ultimately helped contribute to its death. People liked
Hypercard but not enough to pay money for it. By the time Steve killed it, it
was a lumbering zombie of its former self.

------
nicpottier
The thing I've always felt held back these paradigms is something that is
inherent in them, they are too visual.

That sounds crazy, but just look at this article and how he described what he
did. He had to take a million screenshots to show it. The same is true for
say, the Android app builder, or the Lego logic thing.. the way you sure code
is via a screenshot.

And that just doesn't scale very well I don't think. It makes copy/pasting,
the most basic way that people learn, really difficult.

HTML5 is pretty awesome, or rather WOULD be pretty awesome if we could erase
the last 15 years and all start with CSS3 compliant browsers. But it is such a
mess now that I feel bad for anybody starting from scratch.

But the combination of HTML for layout and Javascript for layout is pretty
darn powerful, and I think pretty accessible as well. You could certainly
build something on the order of the simplicity of Hypercard on that stack.

But I do like the author's comments about the shame that there are far fewer
'programmers' than back in the old days. BASIC on the AppleII is of course the
other example (among others).. where it was just so easy and almost natural
for ANY user to start getting a feel for things and hacking around. Losing
that really IS a shame.

------
dave_sullivan
I remember using hyper studio (later version) in 5th grade in ~96. That was
one of my earlier "programming" experiences and I spent a lot of time making a
shooter called teddy bear doom for our class. However, the next year I found
vb and found it a lot more flexible (I also decided I was a pc about that
time)

The author makes an interesting point re: computers as bicycle vs train, that
nothing like HyperCard exists today and apple now has a clear and hard
separation between laying track and riding on it. I agree, but I wonder if
HyperCard (or a modern version) makes the same mistake many wysiwyg solutions
make: if you do something enough, you'll want more capable tools, and if
you're a casual hobbyist, the wysiwyg solution will be too complicated anyway,
with a disjointed interaction metaphor to boot. If I were a 5th grader today,
I think I'd be better served by starting with python than something like
hypercard.

------
pnathan
The author makes a very valid point: the modern Way of personal computing is
about the controlled user experience; allowing people to get their mess all
over with their own work would disrupt that Way.

Don't appreciate the crack about the 'aspie software engineer' though.
Definitely not needed.

------
siglesias
Has this guy played with Interfave Builder lately? I fail to see his point.
Apple has poured tons of resources into making development for its devices
simpler, and that's part of the reason you have so many amateur apps on the
App Store.

Jobs understood the division of responsibility between Apple, with its
extremely limited resources, and its developer community. What wasn't core to
selling computers was cut. We are talking about a company that was 90 days
from bankruptcy when he took over. I think he made a good decision.

If somebody has wanted to do a proper visual programming environment in the
vein of HyperCard for the Mac, what in the last 13 years has stopped them? It
wasn't Jobs.

~~~
jseliger
_Has this guy played with Interfave Builder lately?_

This guy writes a lot of well executed but fundamentally vacuous articles; I
wrote about a previous one here: [http://jseliger.com/2010/09/30/computers-
and-network-effects...](http://jseliger.com/2010/09/30/computers-and-network-
effects-why-your-computer-is-slow/) last year. At this point, PG's essay:
<http://www.paulgraham.com/trolls.html> applies to him. But you wouldn't
notice as much from any _individual_ article or submission; it's only through
the collection that his tactics become apparent.

~~~
wmf
I think he's more of a crackpot than a troll (and I think the difference
matters).

------
ricardobeat
He's kind of pissed off. I see nothing special with it except for the
"natural" language.

~~~
thaumaturgy
Y'know, I can see where he's coming from. I'll get to that in a moment, but
first: I'm starting to get a little sick of HN's tone lately. I'll readily
admit that I've contributed to that in the past, but some of the comments in
this thread ("person is a troll", "writes vacuous posts", "is a crackpot") are
really over the top asinine.

He's a better person than I am, because if it were me, I'd already have a
script in place that checked the referrer and would post a blank page with
"Eat a dick" for anybody coming from HN. If nothing else, it would ensure that
the submission wouldn't get as many upvotes (or would get flagged) and I
wouldn't feel compelled to put up with the abuse.

Anyway:

So, IIRC, my progression as a young programmer went something like: BASIC on a
Commodore 64 / Vic-20, to Logo on I-don't-remember, to HyperCard (and then on
to QBasic and Pascal and C and C++ and OOP and on and on).

HyperCard was amazing because its barrier-to-entry was so, so low, and I agree
with the author's comments that there still isn't anything quite like it. For
one thing, it was on most Macs by default at the time, so you didn't have to
find a copy of the software and install it first.

As he shows, it was a piece of cake to get started with. A budding HyperCard
programmer could easily learn new tricks by downloading anybody's stack and
reading the code. Since it wasn't compiled, you could learn from it. Anything
that anybody else did, you could take apart, and learn how to do.

And it grew with you. You could make something as simple or as complex as you
wanted. My very first, very naive foray into AI was in HyperTalk; I discovered
I could write self-modifying stacks, and decided to see if I could teach a
HyperTalk stack to talk to me like a person.

HyperCard also introduced me to online forums for the first time. I still
remember, fondly, downloading J5iverson's XFCNs from eWorld. From there, I
discovered the world of the early internet -- the alternative to BBSs. Whereas
BBSs at the time let me easily chat with someone else in my town (or, more
often, play TradeWars or something), eWorld let me chat with people "across
the pond" for the first time. For a young kid, this was a life-changing,
world-shrinking event.

I disagree with the comments that SuperCard is a reasonable alternative. I
don't remember the details now, but while I appreciated the addition of color
in SuperCard, it brought with it other complexities that I disliked. I played
around with SuperCard but ultimately went back to HyperCard.

So, what I'm getting at is, if it weren't for HyperCard, I don't think I'd be
a programmer right now. HyperCard was simple enough for a beginner, and rich
enough to keep my interest. It was a _huge_ influence on me. I really can't
overstate that.

Almost two decades later, I was approached by an employer who wanted me to
teach computer programming to his son. His son was young, not yet in high
school, pretty sharp, and, y'know, geeky. Liked video games, liked taking
things apart. Not exactly a challenging pupil in terms of motivation.

I spent a ton of time trying to figure out just what in the hell environment
to use to teach him. JavaScript? You have to know a _lot_ of other stuff
before you can really begin to do anything of value in JavaScript. Before we
could do the calculator example in the author's blog post in JavaScript, I'd
have to teach basics of HTML, the DOM, and eventually we'd either end up using
JQuery or going over the whole "browsers are different in how they handle the
same code" discussion, which, honestly, is one of the most stupid problems in
the history of computing when you think about it.

Anyway, I went through a bunch of options and finally settled on something
called Kids Programming Language (or Phrogram). What a damned mess that was.
It wasn't very long before I had to teach the concept of objects to the kid.
And scope. And then half the time the entire environment would just up and
crash with no helpful explanation. There's a fun problem for a newbie
programmer: write some code, your environment crashes, no explanation.

If the field has improved much since then, I'm unaware of it. Not having
something like HyperCard available to young programmers really is a tragedy,
because it means that future programmers are going to be introduced to
programming in college (which, often, is a joke, and IMO also too late in an
individual's mental development), or they're going to have to tough it out
through JavaScript or Ruby or Python or whatever the inscrutable popular
language-of-the-month is, and that's going to really narrow down the field of
people interested in getting into programming.

Some free market adherents might respond with, "Well, if there was demand,
someone would build it, so obviously there's no demand". Honestly, I find that
entire argument completely boring. It's clear that there _was_ a lot of demand
for it; did nobody want it before it was invented, and has nobody wanted it
since it became no longer supported? I don't think so. I think there is a
market for such a thing, and it just hasn't been built yet.

I really hope it will be. It's already on my list of near-future projects if
nobody else does it first.

~~~
asciilifeform
Finally, a breath of sanity on HN.

------
abecedarius
Alan Kay's STEPS project drew some inspiration from Hypercard. I haven't
gotten to try it, alas. <http://www.vpri.org/pdf/tr2011004_steps11.pdf>

------
SimHacker
Who remembers the HyperCard Smut Stack?
[http://finance.groups.yahoo.com/group/HyperCard/message/2809...](http://finance.groups.yahoo.com/group/HyperCard/message/28096)

------
commieneko
Hypercard was a wonder. I used to teach street people how to make simple,
useful applications that they thought of themselves.

Sure it was limited in what it did, and that was part of its beauty. It was a
tool for quickly hacking together a simple application. A tool that nearly
anyone could learn to use quickly. And it was fun and spontaneous.

And the Hypertalk language was very interesting to work in. It was like a
limited dialect of a spoken language; a pidgin for computers.

------
joshwa
Still surprised that nobody's made the connection to FileMaker.

FileMaker actually _predates_ Hypercard (depending how you define it), and is
similar to the point where you can still find Hypercard->FileMaker conversion
tools.

Filemaker is also screens + controls + simple scripting language (albeit not
quite as easy to grasp as HyperTalk/Applescript), and is wildly popular for an
audience similar to that of Hypercard users.

------
SimHacker
Does anyone remember publishing HyperCard stacks on the web with the WebStar
mac web server? That was pretty cool! It even translated the controls and
fields on the stack to html forms that worked in the web browser.
<http://143.50.28.215/HyperCGI.html>

------
resnamen
I think HyperCard was special in that other people's stacks were easy to come
by, and easy to disassemble. There was no compiled distributable form, all
stacks could be cracked open if you wanted to see how they ticked, and just
modified just as easily if you wanted to see how the program's behavior would
change.

------
boopboop
Filemaker is similar to Hypercard.. <http://www.filemaker.com/>

~~~
derefr
You know what's actually the product I've met with the most similarity to
HyperCard? _Microsoft PowerPoint_. You have cards, buttons that can navigate
between them in arbitrary ways, effects that can trigger on loading or
unloading a card, etc. And for everything else, you have VBA, which, like
AppleScript, allows buttons and fields to do arbitrary things (with generic
COM objects, even!) I once wrote a full-scale Dragon-Quest-style CRPG in
PowerPoint, using the cards as a scene graph; it was actually quite friendly.

~~~
mutagen
There's some truth to this (as appalling as the notion is). While I'm teaching
Python to my 7th grade nephew his school is having him 'program' in
Powerpoint. As dismissive as I am of the notion, it does allow students to
quickly get some stuff up on the screen and start being interactive.

Fortunately my nephew has taken to Python and is even starting to become a
language snob "That looks like a stupid way to program".

~~~
derefr
Hmm... putting PowerPoint and Python side-by-side reminds me a little of Shoes
(<http://shoesrb.com/>), which is also something that "allow[s] students to
quickly get some stuff up on the screen and start being interactive", but is
purely code-based, rather than having any sort of GUI interface construction
tool.

------
almost
Wow, that brings back some happy memories. Writing Eliza style chat bots on my
Mac SE in Hypercard was a lot of fun :)

Fun fact: the best selling game Myst was developed in Hypercard!

