Overview
Are you itching to write some programs for Mac OS X, but don't have a lot of programming background and don't want to invest a lot of time in learning how to code? Runtime Revolution answers that need with their Revolution Studio package. Revolution Studio provides you with all the tools to build Mac OS X applications in a relatively short amount of time. It includes a pre-built application shell, as well as all the graphical interface elements you need to native applications for Mac OS X. Revolution Studio also supports most video, graphics, and audio formats, so you can easily integrate these formats into your program. It uses it's own English like command language, and includes its own debugging and tracing tools. If you want your program to run on multiple platforms, Revolution Studio answers that need as well, by allowing you to write code once, and then build applications from that code for multiple platforms, including Windows, Linux and Sun Solaris.

Requirements

• Mac OS X 10.2.7 or later
• 256MB RAM
• 100MB disk space

Price
Revolution Studio retails for $399. This provides updates for three months. For a year's worth of updates, add $133. Revolution Studio deploys for multiple platforms, but only allows you to debug on a single platform. To debug on multiple platforms requires Revolution Enterprise, which retails for $999. This review is for Revolution Studio.

NOTE: You can download Revolution Studio and try it free for 30 days with no restrictions.

I've coded in HyperTalk (and variants), Java, C (and variants), AppleScript, BASIC (and variants), assembly (PowerPC and 680x0), lisp,
NewtonScript, Lua, JAS, Erlang, perl, and various shells. It was my past experience with HyperCard that originally generated interest for Runtime Revolution.

Installation
After entering your email address on the Revolution Studio download page, you will receive an evaluation key sent to that email address that allows you to use the product for 30 days. The next web page provides the link to download the .dmg file which unpacks the Revolution installer. You do not have to wait for the evaluation key to run the installer.

The installer starts with a welcome screen, then presents a license agreement. After agreeing to the license, you can choose easy or custom install. I chose the easy install, and then is asks where you want to install it (default location is your Applications folder). It also shows you how much disk space will be required (in this case, it was 61MB). The installer then goes through a process of unpacking 10 installers, and finally it performs the installation. At the conclusion of the installation, it provides one more option for installing the EnSharpen Video Codec which is required to view the Runtime tutorials. If you are new to Runtime, then you should install the codec (as I did).

Once installed, the first time you run Revolution, a registration page is displayed.

Runtime Revolution Product Activation page

If you have your evaluation key, or your purchased key, you would enter the information here to unlock the program.

Getting Started
The best way to get your feet wet in Revolution is ty try some of the tutorials. Revolution offers a number of very helpful tutorials, which include PDF and video. Opening up a sample project is also a very good way to become familiar with the software, as it gives you an already built application that you can inspect.

Runtime Revolution Tutorials

Revolution is similar to Hypercard and Applescript in the way that it lets you insert code and run it on-the-fly without having to compile. The command language is also very similar to Hypercard and Applescript, and for those with Applescript experience, you'll find Revolution very easy to pick up. Here is a sample of some Revolution code:

on mouseUp
  -- copy the label of the button clicked on (will be a number 0-9 or .) into the thisKey variable
  put the label of the target into thisKey
  -- copy the runningTotal custom property of the card into the variable currentRunningTotal
  put the runningTotal of this card into currentRunningTotal
  -- if this is empty or the last button pressed was =, then start a new entry
  if currentRunningTotal is empty \
      or last char of currentRunningTotal is "=" then
    -- the start of a new entry must not be . so put 0 before if it is
    if thisKey is "." then put "0." into thisKey
    -- display the value in the result field
    put thisKey into field "Result"
    -- save this value in the runningTotal card custom property
    set the runningTotal of this card to thisKey
  else -- continue entering a number
    -- if the last key pressed was an operator
    if last char of currentRunningTotal is among the chars of "+-*/" then
      -- replace the content of the result field
      put thisKey into field "Result"
    else
      -- put the number after the result field
      put thisKey after field "Result"
    end if
    -- append this value to the previous value and save in the runningTotal card custom property
    set the runningTotal of this card to currentRunningTotal & thisKey
  end if
end mouseUp

In Use
Revolution offers much more, however, then just a simple command language. Revolution programs include code bases, cards, and widgets, all of which can be created and configured within Revolution. After reviewing a couple of tutorials, I created a short and simple application to present a dialog box, and respond to the dialog with a 2nd dialog. The code is as follows:

on mouseUp
ask "What is your name?"
if it is "Solra Bizna" then
answer "Hey! Mine too!"
else
answer "Hello, " & it & "."
end if
end mouseUp

The dialogs are designed easily within Revolution.

Simple Dialog #1


Simple Dialog #2

Delving deeper into the interface, there are a lot of tools available to build upon your application. Revolutions presents a toolbar palette with a number of easy to access tools, and within the various menus are even more tools and functions.

Revolution Tools Palette

In the earlier example, I used simple stock dialogs, but you can customize these dialogs to be exactly what you want. When building your interface windows in Revolution, there are lots of nice tools for creating widgets; however, the placement, sizing and alignment of those widgets to proper interface guidelines is left to the developer. For example, in the simple login window below, I created this in Runtime with a tedious amount of effort manually lining up and resizing interface elements trying to meet Apple's interface guidelines.

Login window built with Runtime Revolution

One of Apple's XCode tools is Interface Builder, and using that tool to build the same interface mockup above did not require much work at all. Interface Builder has built-in automatic widget placement guidelines.

Login window built with Xcode Interface Builder

In the Xcode figure, this window basically represents what happens if you slap a few buttons, labels, and text fields down haphazardly in Interface Builder. All the alignments, placements and sizing are done according to its built-in guidelines. Runtime does not appear to incorporate this, which is why there is painstaking work required to build your interface windows in Runtime (and you may still fall short of Apple's guidelines).

To explore more of what Revolution had to offer, I took the Calculator sample code project and made a few revisions to it, creating a simple "Mac Guild" calculator program. The primary window display was altered to include a Mac Guild logo, and the about dialog box was updated to include a link to the Mac Guild website (note: if you download the Calculator, the about box only activates by clicking on the Mac Guild logo, the "About" menu item was not implemented).

Mac Guild Calculator


Calculator About Dialog

Exploring Revolution through the sample code reveals the inner workings of many of Revolution's features.

Building Your Application Menus within Revolution

After making a few changes and testing them, you can then use build your own stand-alone application using File -> Save As Standalone Application.

Revolution File Menu

Also in the File menu are settings that you can configure for your application, such as setting up the OS X GetInfo data, and specifying whether to build a Universal application, or strictly PowerPC or Intel.

Application Settings

What's really great is that you can use this same code base to build standalone applications for Windows and Linux as well. Below is a folder view of the directory and file structure created from the Mac Guild Runtime project.

Build OS X and Windows executables from the same project

If you want to download the Mac Guild Calculator, you can download from here. To create your own complex applications, a much deeper understanding of the stacks, cards, widgets and command language is in order. For those that would like a detailed in-depth look at the Revolution Development System as presented by Runtime Revolution, you can check out their online White Paper.

Summary
Runtime Revolution is an extensive developing environment that follows the paradigm for HyperCard's user interface. It uses stacks containing cards (like pages in a book), which in turn contain controls and graphics. The language it uses is essentially an upgraded version of HyperTalk, the remarkably English-like language used in HyperCard. It adds some very useful constructs, such as switch statements, that were not in HyperTalk. It also has a number of new facilities for the Internet age, including sockets, integration with the Web, and built-in support for a number of databases. Revolution brings a number of improvements, including more types of controls, multiple windows, and support for color (yes, HyperCard is THAT old). Revolution is very cross-platform, with support for Mac OS, Windows, and a whole slew of UNIX variants (the version reviewed only supported Mac OS and Windows). Like many other cross-platform toolkits, it does not provide built-in interface guidelines, so it becomes a tedious task to ensure the dialogs look good on Mac OS X. If you are already proficient with Apple's Xcode development environment, you may find Revolution to be underkill. If you are looking for an easy to use cross-platform solution, are a beginning programmer on Mac OS X, or an old Hypercard using waiting for an evolved Hypercard product, Revolution may be the tool that you've been looking for.

Pros

• Greatly expands upon Hypercard's user interface
• Enhanced version of HyperTalk's English-like language
• Builds applications for Mac OS X, Windows and Unix
• Good tutorials and sample code projects
• Easy to add internet integration

Cons

• For complex applications, learning curve must be conquered
• Does not provide built-in interface guidelines (like Apple's Interface Builder)
• Price may be a bit steep for hobbyists or freeware developers

Overall Rating

4 out of 5 Mice