
Why Hypercard Had to Die (2011) - tobr
http://www.loper-os.org/?p=568
======
edtechdev
At the bottom of the comments, a member of the Hypercard team said it was
killed in 92, before Jobs returned.

There still is no free development tool out there that matches what Hypercard
did in terms of power and ease of use. We're still coding with languages
designed for constraints that disappeared decades ago.

~~~
jayd16
I've never used Hypercard and I just can't fathom the love for it.

If nothing matches Hypercard, why don't people use it (or some opensource
copy) of it? So many seem enthralled by it but the reality is no one seems to
want to bring it back.

~~~
danaris
Well, the main reason no one uses Hypercard itself is because emulating
classic MacOS is a pain and a half.

I haven't explored all the copies, but the ones I have seen tend to be less
featureful and/or less user-friendly than the original.

Furthermore, probably the best modern software that's similar to Hypercard in
its overall flexibility and power is...the web. Back in the day, Hypercard was
_it_ ; there wasn't really anything else in that space. Nowadays, there's
still nothing that's quite as awesome or matches all its features, but there
_are_ things that are much closer and do a lot of the same things that are
much more accessible than emulating or reimplementing Hypercard.

~~~
cortesoft
Emulating Mac OS classic isn't particularly difficult these days. I use
sheepshaver with great success. I actually DO use it to run my old hypercard
games I wrote in elementary school.

~~~
danaris
Last time I tried using Basilisk II, I managed to get it to be stable (running
System 7 in an emulated...IIsi, I think?), but if I ever tried to change
_anything_ beyond adding and removing disks, it just wouldn't run.

I haven't tried SheepShaver much, I admit, because most of the stuff I want to
run was written for 68k and runs poorly or not at all on PPC.

------
asciilifeform
Author of linked piece speaking. Seems like many readers continue to miss the
essential point, just as they did in 2011:

Hypercard wasn't a gem of graphic design (1-bit colour, plain line graphics)
or of programming language design (one of the many laughable attempts at
"natural language programming") or of high-performance number crunching... but
it was _simple_. I.e., the entire system was _fully covered_ by ~100 pages of
printed manual. It _fit in one 's head_. (And did not take 20 years to fit-in-
head, either, an intelligent child could become "master of all he surveys" in
a week or two.)

Where is the _printed_ manual for the current MS VB, or the WWW's
HTML/JS/CSS/etc stack (yes including _all_ browser warts), or for any of the
other proposed "replacements" ? How many trees would have to be killed to
print such a manual, and would it fit in your house? Could you read it cover
to cover, or would die of old age first?

~~~
314
Do I recognize your name and writing style from Kuro5hin?

~~~
asciilifeform
Doubt it: I have not written at Kuro5hin. (Possibly linked there at some
point, however?)

------
RodgerTheGreat
When Hypercard was new, you could use it to create user interfaces that
_looked_ and _felt_ exactly like all the other Macintosh applications of the
era- within a reasonable margin, anyway.

Basic expectations are now higher. UIs are more visually complex and subtle.
You can't just freehand them with a rectangle tool and a few canned textures.
UIs are expected to reflow to devices with different screen sizes and dot
pitches. Users expect their programs to give them up-to-the-minute information
from the internet, with slick animation and nuanced typography. With
flexibility comes inescapable complexity.

Could you make a tool as easy to use as Hypercard, and let modern users create
useful applications for themselves? Sure, but the results wouldn't be nearly
as nice as the applications built with conventional tools that live alongside
them. I have a tremendous fondness for Hypercard, but I don't think you could
ever make something today which was empowering and full-featured like
Hypercard was for _its_ day.

~~~
justinator
_You can 't just freehand them with a rectangle tool and a few canned
textures._

I mean, why not? If I'm a small business, and I need a custom (in-house) app,
AND I could do it myself with little training, I'd rather do that then not
have the business. (Again) how many businesses run on Excel Spreadsheets? Not
every business can hire a programming firm to make a boutique app that's used
by 100 people.

But I'm also one of those, "Why did FileMaker Pro die?" kinda person. And I
still write Perl. I'm a weirdo, but I'm a pragmatic weirdo that likes to get
stuff done.

~~~
scroot
I do a lot of freelance and I can't tell you how many businesses I've worked
with who had some need that was just a smidge more than their current software
would allow. If there was something in between using an interface and learning
a full-fledged programming stack from first principles, it would go a long
way.

Part of this goes towards getting people -- both today's mainstream developers
and users -- to think hard about what using a personal computer should mean.

I can't think of a better definition of programming than "telling a computer
what to do." That should be the first hint.

~~~
TeMPOraL
That's part of the reason why Emacs has this kind of cult following. There's
always something you need that's "just a smidge more" than your Emacs can do,
but it's _very_ easy to just code up that missing bit. It might be not for
casual user (requires learning some basics of programming), but then again,
the legend goes that secretaries used to use Emacs and like it, for similar
reasons people like Excel today - they need something extra, they can make it
themselves on the spot.

~~~
eitland
And another thing people should learn from that, never underestimate
secretaries, accountants etc.

It is often good to limit what non admins can do to the system, servers, their
computer os etc.

We should also limit who has access to sensitive data.

But I think often companies could be more productive if they taught their
employees to script a bit.

~~~
AnIdiotOnTheNet
> And another thing people should learn from that, never underestimate
> secretaries, accountants etc.

It is difficult for the modern developer to think of users as anything other
than dumb cattle, because doing so would raise ethical concerns about their
high-engagement eyeball-farming products.

------
II2II
There were many reasons why Hypercard died:

Hypercard was very much a product of it's time. Software was far less complex
so it was much easier to create a general purpose development tool for end
users. The author argues that attempts to recreate Hypercard try to do too
much, that is because users expect more of software today. To give you an idea
of what I mean: I used Hypercard to create a cookbook for a family member in
the mid-1990's. You could enter recipes, search for recipes, and even export
them to HTML. While this would have been an amazing accomplishment a few years
earlier, the program was a relic of a bygone era the moment that it was
written. Adding useful features, such as uploading those HTML files to a web
server, may have been possible but would have required extensions to the
language. Plenty of extensions existed, which is how companies like Cyan
managed to produce an amazing for the time multimedia game (Myst) on what most
people viewed as a stack of programmable black and white index cards. Yet
extending Hypercard to reflect the technology of the 1990's would have
transformed a product for everyone to an incomprehensible mass for anyone
aside from developers. And the 1990's were primitive compared to the 2010's,
never mind the coming 2020's.

In a similar vein, people's interests changed. The mid-1990's brought the web,
so people were far more interested in developing for the web. The early days
of web development were quite accessible, was focused upon content (much as
Hypercard was) and allowed people to embed programs within that content (much
as Hypercard did). While Hypercard may have been better for some things and
certainly provided a better development environment, it was also obsolete.

As much as I loved Hypercard, the reality is that it was neglected rather than
buried. It's longevity could have been improved without increasing complexity,
such as adding colour or allowing multimedia files to be embedded (without
resorting to third-party extensions). On the other hand, it would have died
off eventually. The trajectory of web development shows how a once simple and
accessible platform can become so complex that it takes a dedicated student to
learn.

~~~
scroot
Another thing to think about is the metaphors used. Stacks, cards, and
interactive objects on cards were really good metaphors that fit holistically
in the Apple personal computing systems of the late 80s/90s. You're right that
a lot of the computing environment has changed (eg the Internet is like a
natural resource and should be assumed). Whether it is needfully more complex
is another matter.

A key question for designers today is this: what are the metaphors that would
work for today's computing environments in a similarly holistic way, allowing
users to become "authors"? This is something different than a modern Hypercard
clone. I think when people want that old "Hypercard feeling," what they really
want is this holistic nature, power, and ease of use for regular users -- not
simple clones of the old thing.

------
dantondwa
When I was a kid, at the beginning of the 00s, and I was beginning to
experiment with computers, I imagined the future of computing to be about
reducing the complexity of software development as much as possible. I now
realize that I dreamt of something exactly like HyperCards. A world where
machines could be programmed using something resembling natural language and
where anyone could create and share software. At the time, the closest thing I
could find was a Word document where I dragged and dropped buttons to create a
pseudo UI and then imagine that it worked. I wish I had access to something
like this.

I believe that by not having a tool like this, we are taking away from the
majority of the population, and in particular the young, the possibility of
shaping computers for their own needs. A decision has been taken: the user has
to be a passive consumer. It's a mistake and I am really sad about it. It
feels, to me, as if there was a decision, intentional or not, of keeping the
creation of software as a privilege of a few and not a right of everyone.

~~~
brazzy
> A world where machines could be programmed using something resembling
> natural language and where anyone could create and share software.

This is a silly pipe dream almost as old as computing, which reappears every
couple of years in a new guise. When COBOL came out, it was promoted with
exactly that promise, and there were people who seriously claimed that within
a few years there would be no more professional programmers. More recent
incarnations of the pipe dream were "fifth-generation programming languages"
and "model-driven development".

In reality, what keeps "the creation of software as a privilege of a few" is
not a lack of the right tool, but the lack of the _mindset_ of producing
unambiguous, complete instructions and developing your requirements to a state
where it's possible to give such instructions, and facing the many mistakes
you end up making on the way.

That is actually something very difficult to do, and which Average Joe will
_never_ learn, no matter what tools you give him.

~~~
tabtab
A more practical goal is to program in a language or API close to the domain.

------
slowmovintarget
Amid the ranting, the one thought-provoking statement was this:

> The reason for this is that HyperCard is an echo of a different world. One
> where the distinction between the “use” and “programming” of a computer has
> been weakened and awaits near-total erasure. A world where the personal
> computer is a mind-amplifier, and not merely an expensive video telephone. A
> world in which Apple’s walled garden aesthetic has no place.

HyperCard made Macs function as personal computers (the original notion behind
the term) and not as digital appliances (video editors, gaming rigs, media
boxes... etc.)

~~~
eridius
All programming environments do that. And Apple continues to this day to give
away a free programming environment for your Mac.

~~~
slowmovintarget
All programming environments do that for programmers. Not all do that for
people who aren't software developers.

Case in point: Some of the finance people I work with build incredible
spreadsheets. Formulas upon formulas that turn their special spreadsheet into
what is really an application. They're programming, but that isn't how they
think about it (I've asked). They're just Excel power users.

HyperCard aficionados were the same way. They were programming with the
assumption that they just knew HyperCard really well.

You wouldn't be able to sit Douglas Adams (were he alive) in front of XCode
and get the equivalent of his HyperCard stack out:
[https://archive.org/details/DouglasAdamsMegapode](https://archive.org/details/DouglasAdamsMegapode)

The reason is that it requires a dramatically higher investment to create in
XCode. "Just learn Swift" doesn't really cut it as an alternative.

~~~
trop
As an example, a decade ago I taught art students how to code. They had
Macintoshes. I had them download Emacs then taught them Emacs Lisp. As insane
as that sounds, it was interactive, easy to install, and interesting. They
were able to write programs in the REPL after the first class. I wouldn't have
dared to have put them in front of XCode or some equivalent IDE.

~~~
mycall
Why didn't you use MaxMSP or Processing?

~~~
trop
A fair question. An easy answer is that I thought Lisp was pretty cool, and
that the students were capable of it. And, pragmatically, I was experienced
with it, unlike MaxMSP or Processing.

But there was something philosophical: I liked the idea of introducing them to
the feel of fundamental computer science, rather than a nice layer over
computers for artists. (And what artists actually use those nice layers?) I
wanted them to experience an open source ecosystem (unlike Max), and I felt
that the Java-base of Procesing was off aesthetically -- too many layers over
the machine.

Thinking about the OP, I do wonder what it would have been like to teach
coding-for-artists with Hypercard. One thing I love about Emacs Lisp is that
it is only grudgingly visual. That it returns computers to something which
sends output to a TTY. It gives people who have grown up with a GUI a vision
of what computers were like before. I like that Emacs (and Lisp) are things
with a history and touch on earlier eras of computer culture.

------
api
It's a special case of a more general trend: the complete abandonment of what
were once called RAD (rapid application development) tools.

Microsoft also killed WYSIWYG Visual Basic (pre-dotnet), quite possibly the
most productive GUI builder ever made. Not quite as clean as hypercard, but
another example of that bygone era when the user was the customer and not the
product.

The only remaining representative of that era is the spreadsheet, and it seems
pretty solidly locked in. Still I do see a push to replace spreadsheets with
opaque SaaS tools that do specific things.

~~~
slowmovintarget
My first real software dev job was with Visual Basic 3.0, then Delphi 1.0.
This World Wide Web thing was about to happen, but hadn't quite yet.
Compuserve was where the cool kids hung out, and I ran a WildCat BBS with a
buddy out of his basement.

RAD was rad, for a while.

~~~
mycall
WWW was in effect for many years before 1995, although that was its take off
year.

------
redleggedfrog
His acknowledgement of the elephant in the room ("... shit soup of
HTML/Javascript/CSS...") is prescient for 2011. Today it's even worse. How
many versions of lipstick on pig are we to endure (Backbone, Angular, React,
Vue..., Bootstrap, less, sass...) before someone actually makes a sane UI
development toolkit?

Think of the children.

~~~
quickthrower2
The problem is the web was designed for documents not apps. And JS wasn’t
designed for what it does now. The closest thing we had to a sane development
toolkit was Adobe Flex. Someone came up with that and it was ok. But other
more powerful forces particularly Apple made it disappear. Google is in charge
now maybe it’s up to them.

~~~
devnulloverflow
But a lot of the web is in fact serving documents, and using complicated apps
to do it.

It's not surprising, as the two categories do really merge into one another. A
web store is certainly an app -- but it's also the modern equivalent of an
store catalogue, which is a document.

------
TheDong
The author seems to attribute malice to the death of Hypercard, something akin
to "programmers only stand to lose value if users can help themselves".

I think a far simpler explanation is not that control to the ability to
program has been intentionally deprived from users, but rather that the vast
majority of users have no wish to have such a tool, and that Steve Jobs
recognized this.

I think that some proof of this exists: Excel, Visual Basic (and its
formbuilder), Applescript, Autohotkey, etc all exist.

Those tools are all intentionally approachable, as was hypercard, and yet the
vast majority of iphone users would not wish to deal with those tools or
ecosystems. They would much prefer a company do something called "software
development" and give them a working specialized application.

It seems more likely to me that Hypercard was eventually seen as a dead-end,
not as a threat to the existence of selling apple software. Sure, you could
spend significant effort on building a tool that is powerful for novice users
(letting beginners create basic automation and forms easily), but less
powerful for experts (providing less powerful design, abstraction, and
programming features than more typical programming languages).

~~~
Semiapies
It was apparently gone before Jobs got back, but the same point still stands.
The people who put together accounting systems and the like in Hypercard were
unusual in being willing (and having the time) to put forth the effort of
building anything complex. They're almost certainly the same people who would
have put something together in GW-Basic, because they needed what they were
building.

I'm a professional programmer, and I've got enough in my plate to be _happy_
to let clients build some portion of things. But they almost entirely _won
't_, even when given software designed to let them do just that. I've never
encountered any sort of form-builder or report-generator or whatever that was
designed to work for clients "without needing a programmer" where clients
didn't end up asking programmers to do all the form-building, report-
designing, anyway.

It's like they have jobs of their _own_ to do or something. It's like division
of labor _makes sense_ and is inevitable in any non-tiny organisation.

Back when everything was on paper, a technology virtually _everyone_ could
access by reading and writing (or typing), lots of people still had
specialized jobs based around creating and organizing documents within
organizations. Hell, most people are perfectly able to clean and vacuum, but
beyond a certain size of 9-to-5 organisation, places hire janitors.

~~~
TeMPOraL
> _But they almost entirely won 't, even when given software designed to let
> them do just that. I've never encountered any sort of form-builder or
> report-generator or whatever that was designed to work for clients "without
> needing a programmer" where clients didn't end up asking programmers to do
> all the form-building, report-designing, anyway._

Did you interface with the individual workers, or company as a whole? My
experience is that usually, the software _doesn 't_ let workers do what they
need, the workers end up working around it with Excel, and at some point
information will trickle down through two departments and three layers of
managers that some piece of software they're paying for needs adjustment.

> _It 's like they have jobs of their own to do or something. It's like
> division of labor makes sense and is inevitable in any non-tiny
> organisation._

Exactly. But their jobs are almost never correctly captured by software, so
people get creative and invent their own workarounds. The unending popularity
of Excel is a great example of this. Asking someone else to fix your software
for you has large communications cost and time delay; asking programmers has
also a large monetary cost.

~~~
Semiapies
_My experience is that_

And mine isn't. Among some of our clients, being able to do anything in Excel
is an unusual skill. Among others, they do nothing more than basic spreadsheet
work, using nothing more advanced than cross-sheet references. In twenty years
of this job, I haven't run into _any_ of the fabled Excel spreadsheet apps.
I'm sure they're out there, but I'm also sure there's plenty of the world that
doesn't use them.

------
gdubs
Owning a Mac was a very self-selective thing back in the day, and at the time
the “bicycle for the mind” ethos was a deep part of Apple’s marketing.
HyperCard fit that perfectly. So, if you had the money and inclination to buy
a Mac, you were also buying into a philosophy and a promise. That meant that
regular people, not professional developers, were engaged and interested in
making the most of their (expensive) machines. HyperCard was simple to use,
and the return on investment in learning how to build with it was immediately
clear.

Imagine you’re a botanist with the spare money to buy a Mac. You could spend a
few hours with HyperCard and put together a beautiful plant database, full of
pictures and hyperlinks. I love those kinds of stories from the HyperCard era,
and it’s a vision of the power of computing that still resonates today, and is
a big reason why stories on HyperCard are perennially popular.

In today’s smartphone era we have millions of pre-made apps ready to consume
and use. It’s amazing in many ways, but if you think Xcode, or JavaScript and
HTML are the natural successors to HyperCard than you don’t really understand
what was so magical about HyperCard.

------
soapdog
Hey, I took some time to write a reply to that post showing a modern day
alternative:

[https://andregarzia.com/2019/07/livecode-is-a-modern-day-
hyp...](https://andregarzia.com/2019/07/livecode-is-a-modern-day-
hypercard.html)

I posted another comment linking to a modern day HyperCard that was downvoted
without any explanation? I don't understand why it happened. Can someone tell
me?

------
jakobegger
Hypercard was a very general purpose app, but it was a bit of a "jack of all
trades, master of none". I loved Hypercard, but it was never really an actual
good solution for any of the things you may want to do with it.

1) Lots of people tried to use it for making games, but anyone who tried
quickly ran into its limitations. There were a handful of neat Hypercard
games, but when I tried to see how they were made, I saw that they made heavy
use of XCMDs and XFCNs -- custom extensions you had to write in a compiled
language (Pascal? C?). At that point, why would you bother with Hypercard at
all?

2) Another common use case were simple databases, like an address book, or a
stack for all your music cassettes, or something like that. But it lacked
search tools and a way to work with bulk data, so it wasn't really a good
solution for databases. Filemaker was much better for databases.

3) Or you could use it for simple specialized calculators, like a currency
converter. But it was a lot of work to set it all up correctly, and Excel was
actually a lot more useful for these kinds of tasks.

~~~
scroot
> I saw that they made heavy use of XCMDs and XFCNs -- custom extensions you
> had to write in a compiled language (Pascal? C?). At that point, why would
> you bother with Hypercard at all?

Hey, don't forget about shareware culture! You didn't need to code up these
XFCN/XCMDs yourself. You could try and buy them! There was a whole ecosystem
of developers making these things (WindowMaker anyone?) and it worked pretty
well for what it was.

------
vincent-toups
May as well plug a similar article I wrote like 10 years ago now:
[https://procyonic.org/blog/duckspeak-vs-
smalltalk/](https://procyonic.org/blog/duckspeak-vs-smalltalk/)

I actually passed a few emails back and forth with Alan Kay for this.

I short version of this piece appeared as a letter to the editor in the New
Yorker, too.

~~~
carapace
> The certificate for procyonic.org expired on Thursday, June 6, 2019.

> Error code: SEC_ERROR_EXPIRED_CERTIFICATE

~~~
vincent-toups
Oops! Thanks for the heads up!

------
jancsika
1\. What's the equivalent of HTML5 canvas in Hypercard?

2\. Suppose there's a little dataflow drawing program somebody else wrote in
Hypercard. I want to add a binding for my own transient card to pop up on
keyboard shortcut, gain focus, steal all input events, then go away on another
keyboard shortcut (and return input events to their original bindings). How do
I do that?

3\. Suppose Hypercard flourished into the 90s and early 2000s. How would this
alternate-reality Hypercard have dealt with the pop-up ad problem?

I'm sure there are answers to these questions. However, a theoretical
Hypercard that solves them-- plus all the other myriad problems that come from
existing on a weaponized internet-- would make this tech much closer to the
complexity of the modern web than to the original Hypercard.

~~~
wolfgang42
For your #2:

HyperCard is primarily mouse-oriented; I don't believe there's a way to add
keyboard shortcuts (without writing an XCMD in another language like Pascal).
Instead you'd add a button into the other stack (probably on the background)
to 'go to "UtilityStack"'.

This would take you to the first card of the stack you'd created, which
naturally takes over since it's the one being shown (no need to explicitly
'steal' events). Once you're done there, either use Go > Back (Cmd+B, I
believe) or have a button on the card with the script 'go back'. This takes
you to the previous card the same way that the back button in your browser
would, and likewise events now go to that card with no explicit rebinding
required.

~~~
scarface74
I think you could add keyboard shortcuts. You could definitely add menu items
([http://folkstream.com/muse/teachhc/menu/menu.html](http://folkstream.com/muse/teachhc/menu/menu.html))
and you could intercept keydown events at the stack level.

~~~
wolfgang42
Huh, interesting. They must have added that in a later version than I was
using, my copy of "The Complete HyperCard Handbook" doesn't mention "create
menu" or keyDown handlers at all. Thanks for the correction!

------
lioeters
Another article that pops up regularly on HN, on this relevant topic:

The coming war on general-purpose computing

(previous discussion:
[https://news.ycombinator.com/item?id=19872364](https://news.ycombinator.com/item?id=19872364))

There are a number of admirable attempts to create the "next Hypercard" on the
web. I haven't encountered one that really sticks, but as an old(er) timer who
remembers the earlier era of personal computers - where the user was really
the user, not "used" \- I see that it's an important dream to keep alive,
especially in our current cultural context of an increasingly exploitative
web.

------
japanoise
Loper-os seems to suffer from the same problems as a lot of "unix hater"/lisp
weenie types: while he does point out real flaws in the computing of today, he
seriously lacks in a competent, coherent, non-vaporware alternative. His blog
is now nothing but bloviating about bitcoin

~~~
asciilifeform
Author of linked site speaking. Are you sure you are reading the same page? I
had half a dozen articles re Bitcoin, the last in 2014...

~~~
japanoise
Your most recent article, [http://www.loper-os.org/?p=3440](http://www.loper-
os.org/?p=3440) is tagged bitcoin, and in fact if I click on the tag, I see an
awful lot of articles written in the last few months [http://www.loper-
os.org/?cat=42](http://www.loper-os.org/?cat=42)

~~~
asciilifeform
I do have a multi-chapter series on constant-time integer arithmetic -- indeed
tagged incl. "bitcoin", as it is meant to be used in (among other places) a
rework of the client.

You evidently spent at most 3 seconds reading the link; wouldn't kill you to
spend 5 seconds and see what is behind the tag.

------
_bxg1
This is a pretty incendiary and bitterness-laden rant. I enjoyed the trip back
in time but the last paragraph, for me, pretty much nullified any actual
points the author was trying to make.

~~~
braythwayt
I empathize with your feelings, but iobjectively, if an author makes three
good points and then pours toxic emotional sewage all over them, the good
points are still the gooid points.

We may not want to read the author esposuing them any further, who needs toxic
sewage? But the sewage cannot nullify a point that we recognize as true. Its
truth is independent of whether the author is a goofd or bad person. Its truth
is independent of whether the author argues it well or poorly.

It's unfortunate when good points get covered in toxic emotions. I wouldn't
say that we should read such things whether we like it or not, but having read
them, I say we take the good points and repackage them in less vitriolic
prose.

~~~
_bxg1
It undermines his judgement. He makes sweeping, subjective arguments, which
isn't inherently a bad thing but it means those arguments are more than just
cold facts. The amount of heated emotion he apparently has around this subject
means that his ability to draw conclusions from "soft" information is
compromised.

------
dang
Discussed at the time:
[https://news.ycombinator.com/item?id=3293657](https://news.ycombinator.com/item?id=3293657).

------
mgbmtl
I also had an early accidental contact with HyperCard, and sort of learned the
basics without knowing it. I was looking for something equivalent to show my
12 year old, who is into Minecraft and generally open minded about learning
geeky stuff (they've had Sketch and electronics basics in school, likes to
plays with LEDs, 3d print, etc). I found Sketch a bit too limited, despite a
few attempts, it didn't work out for me.

I don't know much about game programming, but we ended up exploring Unity 3D.
There are tons of videos online, it works well under Linux, and you can do
lots of different things with limited programming. Probably not perfect, it's
just for playing around, but curious to hear other experiences.

~~~
PinkMilkshake
If Unity worked out well then Godot could be a good choice. It’s conceptually
simpler but is still very powerful.

~~~
follower
I had just signed in to suggest Godot myself. :)

For the GP, here's the Godot web site:
[https://godotengine.org/](https://godotengine.org/)

While Godot has its idiosyncrasies, in terms of being a tool that made it
possible to actually get something done and _playable_ , I've been pleased
with the results I've gotten from it so far.

The ability to export to HTML5 in addition to desktop & mobile is great for
getting a project in front of people quickly--particularly useful for things
like game jams: [https://rancidbacon.itch.io/sheet-em-
up](https://rancidbacon.itch.io/sheet-em-up) (which I created as my first game
jam entry :) ).

Godot is also released under a MIT license and has multiple full-time
developers working on it (supported in part by monthly community donations).

------
8bitsrule
Here's what Atkinson said about it in 2002:

[https://www.wired.com/2002/08/hypercard-what-could-have-
been...](https://www.wired.com/2002/08/hypercard-what-could-have-been/)

More clues in this (2016?) _Twit_ interview (including the phrase
'Sculleystink' at about 16m in):

[https://www.youtube.com/watch?v=INdByDjhClU](https://www.youtube.com/watch?v=INdByDjhClU)

~~~
Torwald
I am a fan of Leo, but he also tends to fall on my nerves with constantly
interrupting people. Atkinson is great in just not letting that happen, FUN!

------
galaxyLogic
I think Web killed Hypercard. Hypercards were kind of components and that was
their power. Create onbe card at a time then connect them together. But so
were/are web-pages.

But you could not connect a hyper-card to another card created by another
author executing on another machine. That was the mind-blowing concept of web
and it quickly became clear that that is what we wanted to do, not dabble with
our own stack of "hyper" cards.

For one thing web was not tied to Apple hardware

------
nlawalker
Hypercard's "letting regular people build useful things" ethos lives on in
IFTTT, Zapier and Microsoft Flow. In 2019, it's not super useful to many
people to be able to mush together some buttons and textboxes into a desktop
UI, but it's fantastically useful to be able to mush together their email,
calendar, SMS, Instagram, Facebook, Twitter, Dropbox, Spotify, Alexa, home
automation etc.

~~~
TeMPOraL
Sorta, kinda, not quite.

That's the problem with SaaS - they take your data, silo it up, and expose
through highly limited and tightly controlled APIs. Sure, I can make IFTTT
save a copy of every picture I upload to Facebook into my Dropbox account (or
at least I could, I think it broke). But I can't make it save that picture _in
original size_ , because someone didn't expose some option, or an endpoint. Or
I can't make IFTTT save all the reactions to my post into a CSV in the format:
<<datetime, which post, who, what reaction>>, because such endpoints again
aren't exposed or integrated. Etc.

I get that IFTTT & folks are doing the best they can, but the companies
they're trying to "mush together" made their money on preventing
interoperability, so it's still very far from both what could be and what
_used to be_ possible.

~~~
alexis_read
You could try nodered-self hosted or cloud options. It has plugins for most
stuff including GPIO, MQTT, HTTP, email, twitter.

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

------
z3t4
Business and engineering rarely goes hand in hand. So you made something that
never wear and tear, boss orders you to redo the formula so it has to be
replaced more often, resulting in more sales. Or you made something that
enables the user to create infinitely amounts of what your company sell, boss
tells you to erase all copies of it. etc.

------
drngdds
"If you disagree with my barely-argued opinion, you're autistic" isn't a great
way to close an article

------
PeterStuer
Hypercard was obsoleted by the www. To survive it would have had to become a
visual HTML editor. If you are looking inside the Microsoft backcatalog it is
not VB that was the Hypercard heir, it was Frontpage for consumer-and Infopath
for business applications.

------
LeoPanthera
archive.org now has the ability to run uploaded Hypercard stacks in your web
browser.

Example:

[https://archive.org/details/hypercard_autodiagnostics-25](https://archive.org/details/hypercard_autodiagnostics-25)

------
mgamache
I tried to get a license for SuperCard (it had color), but had to use resedit
+ HyperCard to add color textures... Miss those days (not so much)

off topic (but same era) I loved MacProject... yet another Claris step child
software. Moof!

([https://en.wikipedia.org/wiki/MacProject](https://en.wikipedia.org/wiki/MacProject))

------
mgamache
Hey I just noticed that SuperCard is still alive and offers HyperCard
migrations:

[https://www.supercard.us/](https://www.supercard.us/)

(SuperCard was a commercial HyperCard alternative)

------
jdlyga
I spent a lot of time as a 7 year old playing around with Hypercard. Gave me a
lot of good early exposure to building interfaces.

------
mgamache
Okay this may be unpopular, but I felt like Microsoft VB 3.0 (for me) was a
better version of HyperCard on a worse platform.

------
dnicolson
I wonder why there was a "Scripting language" dropdown menu, was anything but
HyperTalk ever possible?

------
rmrfrmrf
From my perspective, HyperCard lives on in 2 distinct branches: webapps and
PowerPoint.

------
tluyben2
LiveCode is pretty nice. If you want something _fast_ & crossplatform it is
kind of hard to beat. I find the language awful (far too verbose for my taste)
but I would say most people here would have that going in 1 to a few days to
be productive. The forum is active and people answer fast when stuck.

------
crb002
How hard would it be to port HyperCard to Qt? No reason we can't have it back.

~~~
braythwayt
If the LiveCode people can get HyperCard running on *nix, I'm sure HyperCard
could be ported to Qt.

[https://en.wikipedia.org/wiki/LiveCode](https://en.wikipedia.org/wiki/LiveCode)

------
enos_feedler
I could imagine Playgrounds app turning into such a thing

------
genuineDSD
Uhm, I have grown up with Macintoshs and I still use them. So, my comment has
at least double the emotional intensity compared to the author's. ;-) In all
seriousness, I say this because it is clear that his post is mostly based on
an emotional attachment to a tool, not on critical thinking.

Maybe I misunderstood, but if I understood him correctly, the premise is that
Hypercard would still be around if it did not collide with Steve's vision of a
world of dumb users and smart engineers. This is wrong on so many levels, I
don't even know where to start. Are you willing to learn?

First, Hypercard was created when 13" 256-color displays were state of the art
(actually even earlier) and there were exactly two devices to interact with
your Macintosh: a keyboard and a mouse. So, for simple tasks, it was quite
easy to create a tool that would allow you to stick together a simple program
using clicks and a verbose scripting language. Nowadays, however, general
purpose applications are supposed to work on a variety of devices, from 4"
phones with touchscreens to desktop-Macs supporting 27"\+ screens being used
with traditional keyboards and mice. Maybe this will change in the future, but
if you want to precisely describe a structure (GUI-compontents) in a
generalized fashion, a textual representation (e.g. react-components), so far,
is just superior to any GUI-tool that is around.

When hypercard was created, VCS (such as git, svn, etc.) weren't really a
thing. Most software was developed in about the same way as you created
Hypercard projects: You made changes to your main copy and that's that. Today,
you don't even think about starting a software project without having vcs in
place. Similarly, when Hypercard was created, many software methodologies
weren't a thing: Unit Testing, Integration testing, etc.

Now, I am a software engineer, and while I never wrote Hypercard applications
myself, I once found myself maintaining an Filemaker-Application. Filemaker, I
reckon, is very similar to Hypercard in that you plug together your app using
a GUI and some overly verbose, pseudo-simple scripting language. And, needless
to say, this was an absolute disaster: In the beginning, it was a simple tool
that automated a couple of tasks and it was created in a very short period of
time, thanks to the easy-of-use of Filemaker. However, as with all other
tools, it grew in complexity. Now, ever tried to track changes in the source
code using Filemaker-files? Ever tried to unit test Filemaker-code?

And don't get me started with the absolute ludicrous idea to use programming
languages that resemble a natural language. Claiming that this is as effective
as using an abstract language is akin to describing complex mathematical facts
using only a natural language—while possible, it is completely unfeasible.

------
ptx
Where is the eval call in the hypertalk script? Is it "value of" applied to a
string, i.e. "value of value of card field"? (I assume it's not simply "value
of" since that doesn't seem like it would work for the operator buttons in the
example - or does "/" or "+" evaluate to itself?)

This seems like a good reason to kill the language at least, in the Internet-
connected era. In a language that's supposed to read like English, eval should
be "dangerously execute untrustworthy text from ... as program instructions"
or something, not a polymorphic call to a common operator accidentally applied
to the wrong type.

------
NikolaeVarius
The fallout from being able to used to cause people to suffer brain damage
when opened also probably contributed

