End User Programming Packages: Revolution

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.


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:

  • Revolution home page – see Rev Journal also
  • RR list archive
  • Tutorials – .pdf available
  • the Manual [.pdf] – WIP
  • tutorials and guides
  • tutorials and guides
  • lstacks and tutorials
  • BYU tutorials
  • stacks and tutorials
  • more stacks and tutorials
  • Dan Shafer’s book
  • Daniels and Mara – the Galaxy IDE
  • The MetaCard IDE
  • Fourth Worlds Devolution developer toolkit

    Links to some other packages mentioned:

  • Dabo
  • the Gambas Shrine
  • rebol
  • knoda home page
  • Glom
  • Datakiosk
  • PythonCard
  • Flamerobin – a front end for Firebird
  • Rekall
  • Kexi – part of KOffice)

    1. 2007-01-09 6:00 pm
    2. 2007-01-09 6:10 pm
      • 2007-01-09 11:44 pm
      • 2007-01-10 6:23 am
    3. 2007-01-09 6:15 pm
    4. 2007-01-09 6:20 pm
      • 2007-01-09 6:51 pm
        • 2007-01-09 6:56 pm
    5. 2007-01-09 6:45 pm
    6. 2007-01-09 6:57 pm
      • 2007-01-09 7:12 pm
    7. 2007-01-09 7:39 pm
    8. 2007-01-11 10:22 am