Guest post by Revolution is descended in spirit from Hypercard (HC). When Apple’s support for HC withered, Scott Raney developed Metacard (MC), a near clone. Metacard was then bought by Revolution (RR), based in Scotland. Metacard was two quite distinct things: an engine, and an IDE. When Metacard was sold, the MC IDE became public domain. It still exists, is volunteer maintained, and it can be used with the latest RR engine. Some on the RR user mailing list prefer the much simpler MC IDE to the RR IDE, at least for initial project development. Other IDEs are possible, and there is a third party (non-free) IDE called Galaxy. Note: This is, as stated in the title, an end user’s and not a developer’s perspective. Developers will be struck by quite different things and have quite different experiences. Revolution is available for most platforms – Mac, Windows, Linux, Unixes, though Mac and Windows are the only platforms with the latest releases and with all of the available add-ons (such as Valentina and Galaxy). It has the interesting feature which not all cross platform development tools have: that you can write and compile on one platform for any other. Despite some complaints of detail, this seems to work quite well. At compilation time, if you don’t already have an engine for your target platform, one is automagically downloaded. Filemaker by contrast is cross platform, but you need to compile your standalone on the platform it will run on. RR also has a third party cross-platform player, called StackRunner, and a low cost entry package, Revolution Media. This doesn’t create standalones, and so far it only comes in Mac or Windows flavors. Linux is coming soon. The pedigree is appealing to anyone who ever liked and used Hypercard on OS9. Like HC, it is a hybrid of a professional developer’s package and an end user’s package. We shouldn’t forget that some very striking professional things were done in Hypercard, including the first Myst. But it was also accessible to anyone computer literate enough to make a reasonably complex spreadsheet and was an easy entry into learning to program. Revolution shares this. Revolution itself seems to be a fairly small organisation, but it has a strong developer community and mounts well regarded annual conferences for its users and developers, the last ones being in Malta and Monterey. You can’t recount this history without an attack of the ‘if onlys’. If only Apple had realised what it had in Hypercard. If only they had ported it to Windows, instead of seeking with their usual fatal blindness to make the world buy hardware it didn’t want to get software it would have wanted. If only, having decided not to support it, it had open sourced it or let someone else run with it. But we are where we are. One or two things. There are a few things the new (amateur) user will soon become aware of about RR. One is that it is not especially cheap for an amateur. A Studio license costs 266 Sterling, and add-ons, such as the Valentina database or the Galaxy IDE are moderately expensive too. I benefited from RR’s generosity with an upgrade from an old Express version, but if you don’t qualify for something like this, it’s quite costly. The Media version at 33 Sterling is a possible and much cheaper alternative if you don’t want the whole works. Second, it has the most wonderfully active, helpful and friendly mailing list and forum you will find anywhere. The contributors seem to be long time HC/MC/RR users of great goodwill and expertise, and responses and discussions are almost always good natured and informative. In fact, the Revolution crew generally are distinguished by niceness. Third, its documentation is a bit sketchy. There is a very nice introductory book by Dan Shafer ‘Software at the Speed of Thought’. There is a partially complete pdf manual on the RR site, which seems to have chapter headings only at key points in the narrative (like, arrays!), and which has made no progress since its last edition in the summer. There is a nice online comprehensive dictionary of the language, which is built into the IDE and well cross-indexed and linked. There are some very good beginner’s tutorials on the RR site, and quite a few sample stacks to download and take to bits to look at. The Novell Suse site has some very fine tutorial examples showing how to use RR with the Linux shell. But if REALBasic’s documentation is 8 out of 10, one would have to rank RR’s around 4. A classic example is arrays. RR arrays are associative and dynamic, and according to the best available (3rd party!) documentation it is said that RR ‘by making what I call “string assumptions” can allow the arrays to mimic true multidimensional arrays, even though under the hood, they are considered to be single-dimension string-based arrays’ (Source: Sons of Thunder Software: Understanding Arrays). You might expect this interesting behaviour to be covered at some length in the official documentation. Alas, it ain’t. Type ‘array’ into the online dictionary, and you find nothing about arrays. To get limited clues about them, you have to know to look for ‘keys’ and ‘special properties’, and even then it’s not very enlightening. There is also a table object which you can paste onto a card instantly with a flick of the wrist. Then try to figure out how to use it! In fact, the state of the documentation was strikingly illustrated when, in recent posts on the mailing list, it was seriously suggested that an enquirer should get hold of Danny Goodman’s books on Hypercard – books published 8 years ago on a now discontinued language on a discontinued OS! Another poster said he relied on the old Metacard documentation supplemented with pasted in contributions. Revolution is making serious efforts at improving documentation, but they are not there yet. Professionals seem to do fine with only the on-line dictionary of the language. The bottom line is that for a beginner, getting started is easy and there’s lots of material. But finding out how to do some specific x after that can be a chore. Using Revolution RR keeps the original HC metaphor of the stack of cards. An application is a series of stacks of cards. Within a stack cards are metaphorically one behind the other. Stacks can have substacks. Cards contain objects, such as fields or buttons. Writing a program in RR consists of first creating a stack or stacks, then creating cards, then putting the appropriate objects on them. Actions or events involving these objects result in messages being passed (roughly) from object to card to stack to system, and you write scripts to handle these messages. The language in which this scripting is done used to be called Transcript, now Revolution, and is close to the classic Hypercard scripting language. It has quite good support for regular expressions and text and string manipulation – so that the refugee from the Linux shell may at some point have the blinding flash of misleading illumination that he is really dealing with a clone of awk with a gui stuck on the front. It’s much, much more than that of course, but it is certainly very powerful in dealing with the kinds of problems that awk is/was used for. I’ve used it in anger for two tasks, apart from playing – ie things where the result was going to be used seriously by some other person or group. One was parsing and extracting data from a file, which a friend did. One could have done it in awk, and it would have been considerably more compact and probably run faster, but this took a weekend to do, is easy to use, and works fine. Perl is presumably the natural choice for this for most people. The second is a very simple little application for an organisation where the computer users can’t be expected to use the keyboard at all. They will simply turn on the computer, and use a barcode reader. In addition to reading in codes of items, there will be two or three barcodes corresponding to buttons: delete, total ticket, stuff like that. The main issue has been figuring out how to handle lookups and store data. You can use arrays (yes, them), if you can figure out when and why and how. You can store in an external text file. You can store on a series of cards, or in a field or fields on one card. The great flexibility of the language in allowing you to create new fields or cards as needed, and inheriting properties, makes all these choices confusingly readily available. Or you can use a real database engine like mysql or sqlite, or the intriguing No Sql, if you can figure out how to connect and use. Sometimes there is too little documentation for a new user on how to do one of these, sometimes there’s too little on why to choose one rather than the other. The thing that is super fast and very easy is to layout the screens, and to the extent that this determines how the application is going to work, this ease, and the requirement to start there, enforces a certain discipline of design that the amateur will find helpful. You pretty much have to plan it out before you start, because if you don’t, planning is the first thing you’ll find yourself doing anyway. You can also use a sort of interactive interpreter called the Message Box, to perform your scripts one or a few steps at a time, which makes it easy to debug. In addition, the fact that you are always scripting some object – card, stack, field, button – means that you necessarily write your application in a modular way one piece at a time. Write a bit, then test it, then move on to the next chunk. It can be a little disconcerting to have one’s program scattered over lots of objects without a few pages of code to look at as a whole, but probably the modularity more than compensates, at least for small projects. You have to discipline yourself to avoid go-tos. If you want to write spaghetti, this modularity makes it easy, though you’ll soon realise how impossible it also makes it to keep track of the strands, and stop. There is an application browser which displays all the different objects in an application, so you can see at a glance what stacks you’ve made, what cards are in them, and what objects are on those, and there are some third party development add-ins, not all of which work on Linux. For a Linux user, it’s a bit irritating that virtual desktops aren’t supported. So you sit there with five or six empty workspaces, and on the RR one, you have all these windows stacked up one behind the other getting in each others way – application browser, cards and stacks, script editor, card designer, message box – and you cannot move a few of them away to get rid of the clutter. This may change in the next upgrade. It does give you a vivid insight into what the usability gurus have missed in every Mac and Windows release for the last twenty years, and a deep desire to watch someone else trying to work like this, rather than have to do it yourself. Alternatives What are the amateur’s alternatives to RR? Here are a few. For a real database application, Filemaker is the obvious one. It is easy and powerful, if not cheap either. But, it doesn’t run on Linux. PythonCard is a Free/free package using the HC/RR/MC card and stack metaphor, but with Python as the scripting language. Documentation of PC is pretty sketchy, but of course Python is very well documented and cross platform. There is a fairly low activity but generally helpful forum, and some decent starting tutorials, a couple by Dan Shafer. Then there are the various Free database packages – Rekall, Knoda, Kexi, Base, Glom. Knoda is generally rated the best of these. The difficulty for the amateur with all of them will be scripting, which is pretty much undocumented or inaccessibly documented. If all you want to do is make tables, put data in and access it, any is probably fine. But then, you can also use Tellico, which will give you a great premade environment for handling anything that can be construed as a non-relational collection. And Treeline is very interesting on Linux as a powerful package for less structured data. For RAD type packages there’s Dabo and Datakiosk. REALbasic is a non-Free (but financially free for Linux) serious development environment, exhaustively documented, maybe too steep a learning curve for the amateur? Gambas is very promising, but only runs on Linux, sketchily documented (but VB is well covered and that’s probably the starting point). It’s intended as an open source replacement for Visual Basic. The (non-Free) sleeper for our purpose may be rebol. This is fast, small, easy, very high level, runs on everything, and has a great series of tutorials and examples as well as comprehensive detailed manuals. Entry level versions are financially free but not open source. Recommendation for the amateur? If you can afford the full Studio version, or tolerate the limitations of the Media version, RR is not a bad choice. There are a few bugs and irritations in the current Linux version, but he similarity to the Hypercard environment, the cross platform capabilities, the choice of IDEs, and the general pleasantness and helpfulness of the Revolution people are strong motivators. It’s not perfect, but it retains loyalties, not just mine. It’s the closest thing left standing to Hypercard, which means that it’s really the closest thing left to an end user package which permits as much programming as you want to get into, but also allows you to produce your own small apps with minimal amounts. If you can’t afford RR or are committed to open source, and you still want the card/stack metaphor, try PythonCard, of which maybe more later depending how people like this piece. If you aren’t committed to the card/stack model, but want something cross platform and high level and financially free, try rebol, of which maybe more later. If all you want to do is process strings of text and get mental exercise while doing it, there is always awk! The exercise can be guaranteed. Blood will flow in the brain. How much text will be processed is a different question… Selected Revolution Links: Links to some other packages mentioned:
Never used it as I rarely stepped across a Mac a few years ago but based on its description, it sounds an awful lot like Macromedia's Authorware which was all the rage on the late nineties.
Authorware offers pretty much the same capabilities but instead of the card/stacks paradigm, you had a white book where you could start a sort of flow chart (kinda like Visio) where each block had a special purpose: losangles were interactive if-elses, rectangles would be the whole screen (or portions of it) and so on and then you could literally “draw” your application connecting the dots.
As any other Macromedia product back then, its scripting capabilities were provided by Lingo which was quite nice and powerful (Director users will agree with me here) and it also could be extended by using external ActiveX controls that one could develop on Visual Basic.
Authorware and Director kinda overlapped on each other's features and intended uses, but I always felt Authorware as being more natural and pleasing to use. At the time, I was working for a small multimedia shop (you know, companies that produced websites, interactive CD-ROMs and such) and we used it a lot to produce interactive online courses.
The final result needed to ship certain runtime dlls but it was OK from a performance point of view. I really wish that something open source were made along these lines.
I'll take a look into PythonCard now thanks to your article as it sparked my curiosity about it…
Edited 2007-01-09 18:01
It is just too expensive IMO.
I think that it is reasonably priced when compared with the commercial competition (Omnis, RealBasic, Wirefusion). When Revolution was marketed as MetaCard some years ago, I mistakenly dismissed it as it seemed like it was a toy – and it was about $1000. Revolution is much more reasonably priced, and comes in a variety of formats with different pricing (the cheapest format being about $50).
If there was an open source tool that offered the ease of Revolution and the cross-platform deployment, I might well be using that. But there isn’t. The persistence metaphor behind it (cards and stacks) is very simple, the language is very easy to read, and the message-passing paradigm is really very powerful.
The documentation does need work – it was historically much better a year or so ago, but it was drastically changed because of (IMO unjustifiable) user complaints. But there is nothing stopping new users from downloading earlier versions and taking the documentation from that whilst Runtime Revolution are working on the current docs.
For a hobby, for quite a lot of people, yes it may be too expensive in the full version, and they should then probably try either the Media version or PythonCard, which will be harder work in some ways but is also quite interesting.
But for a professional, its just part of the tools of the trade, and its quite competitively priced compared to similar things on the market.
Revolution also do the usual educational discounts.
…but, having tried Hypercard, I daresay it lacks a lot of features.
Also was a commecial product in this category, mainly in the pre-web, multimedia CBT authoring days. The stack metaphor was less pronounced, but it was there.
I’ve always found metaphors– in the form of cards, psuedo-objects, or pages (web pages)– to be very useful for beginners. I question whether the web would have taken off if the “page” hadn’t been the foundational unit.
I’ve been curious about Revolution for a few years, but I’ve been reluctant to dive in. I don’t particularly relish learning the nuances and special workarounds required by these types of tools. Perhaps Revolution script is more standard than the other hypertalk/card/script languages.
Oh man… I can't believe that I forgot to mention ToolBook. Most of those CBT authoring applications were indeed based or at least inspired by ToolBook. It set the standard for them.
Is it still around? Oh, the memories… ;P
there are toolbook converts in the Revolution community, I met some of them during our conference in Monterey called RevCon West, they were very excited about rev…
My name is Andre Alves Garzia. I am a professional developer and I am making a living out of coding in Revolution. Most of my work is network related or CGI related and I use Revolution for them all.
From my point of view, Revolution is the tool of choice for the following reasons:
* No need to compile something to test it. Like HyperCard, as soon as you code it, it is live. No need for the tedious write-compile-run-debug loop, Lisp coders will recognize this as a real productivity booster. You can code faster!
* Revolution is built in Revolution. The seasoned Revolution user will notice that Rev is built in Rev, you can access the IDE scripts and plugin scripts (you can protect your own scripts with password case IP is an issue for you.). With that power in your hands you can customize everything to suit your workflow. There are Revolution users with IDEs so customized that you barelly recognize the product, will all new tools, palettes, editors and yet, our code can be shared and will run in each other machines.
* The wonderful ‘How to use Revolution’ mailing list. As the article quotes, the mailing list is an invaluable resource with a friendly community such as I never saw. Emails with doubts or request for comments are discussed in a civilized tone with no verbal violence. People share code, patterns, insights even business practices there. Anyone that ever tried to join some linux forums with newbie questions know how bad some communities can be.
* Revolution has a english like programming language that is easy to read and makes sense, nothing against Perl or intercal, but Transcript is a wonderful language and having a english-like language is a good thing since it helps the newbie developers without sacrificing anything. Easier to explain what ‘add 1 to i’ does than ‘i++’. Not everyone out there is a CS major.
* Revolution is a RAD tool that can create fully functional GUI applications that are cross-platform out of the box using native look and feel in each plataform. It has database support (MySQL, PostgreSQL, ODBS, Oracle, SQLite, Valentina), it has lots of network features from low level socket routines to high level URL keyword.
I spend most of my time inside the Revolution IDE. As the article spoke from an end user perspective, As an example I’ll tell what I’ve been doing as an end user latelly. I just created a tool to do CRM from inside Rev, It binds with apple address book for contact storage and spotlight for file management. The team I work with use Revolution for version control of our projects. I have Revolution communicating with all kinds of applications here since Revolution can execute AppleScript (or any OSAX language) code. For example when some client call me on skype, my CRM thing running on Revolution gets his name and pops all the data I need to work/talk with the client, all the development diaries, files related to his project and the like. This whole CRM tool was created in 10 hours, try that in C++ or C…
The documentation needs some addings such as some starting point for new users, but all the docs are there if someone checks the dictionary or the howtos.
I use Revolution Enterprise version that allows me to run Rev in any OS which Revolution runs and deploy in any OS too. I usually develop on Macs and deploy on Linux servers. I also run revolution in windows xp to test gui applications I build. This tool allows me to create visually rich applications very fast and has all the features I need for my line of works, I couldn’t find any other tool that presented such values for me. I don’t think it is expensive as it paid itself many times over by allowing me to have a very pleasant and happy development experience (hey, everyone has a favorite language after all).
why not just use it?
Uh, because it only runs on Windows? Revolution is cross-platform.
I was an early HyperCard user and developer and I’ve been using Revolution now for several years. For what it offers, I think it is badly UNDER priced, not overpriced as has been suggested here. And despite its HyperCard roots, it overcomes or eliminates virtually every limitation of HyperCard that made that product less than the resounding success it might otherwise have been.
1. It’s full color, no kludges.
2. It’s cross-platform including Linux.
3. It creates true standalones, no runtime required.
4. It implements custom properties to avoid many of the programming holes and hassles in HC.
5. Apps it creates are blazingly fast.
6. 90% of what one needed to write an external for in HC is built into the Transcript scripting language.
There are lots of other things but those will probably suffice to dispense with the “it’s only HC redone” myth.
I call it HyperCard in color, cross-platform on steroids. (Appropriate apologies to Mark McGwire and Barry Bonds, et. al)
This is an insanely great development tool for people who want or need to develop cross-platform applications including those that use the Internet. While I wouldn’t use it to create a word processor or a spreadhseet program (who needs more of those anyway), and it lacks the ability to deliver apps in a browser easily (though it has an available browser plugin that’s killer), there isn’t much else that *I* want to build that I wouldn’t turn to Rev for as the proper tool.
If you are working on a medium-size project, and you need an example of the subject matter expert’s line of reasoning, any of these *Card stacks is a marvelous way for him to demonstrate how his stuff works, without being a programmer.
By the way, later versions of HyperCard (commercial, sold separately, if I recall correctly) -were- in color.