Volume Number: 20 (2004)
Issue Number: 2
Column Tag: Reviews

REALbasic Review

by Guyren G. Howe

A Better Visual Basic Than Visual Basic

I always figured that my plans for world domination hinged on being able to quickly write great, easily maintained programs on all the major platforms. I also need my less experienced minions to easily learn to do the same.

Quake in fear, for REALbasic may be just what I'm looking for.

In this review, I'm going to give you a detailed tour of REALbasic, pointing out the interesting features of the language, the IDE, the debugger, the company and the community (because the latter are also very important to the value of a programming language). My aim will be that by the end, whatever your needs, you'll have a good idea whether REALbasic will help you to fill them.

I'm going to mix up talking about the existing 5.2 release and what looks likely to make it into the 5.5 release. I'm doing this because REALbasic is developed at a snappy pace -- a new version every six months -- and because some of the impending features might well be important to you. Contrasting the two releases will also give you an idea of how quickly the product is improving.

Some of what follows will be a bit technical, so I wanted to put this right up front: REALbasic is excellent for beginners. If you're a beginning programmer just wanting to knock together some "basic" programs, REALbasic has that covered. If you're looking to learn programming, REALbasic is very accessible, and you can gradually ramp up to using more sophisticated techniques once you're ready for them.

If you are interested in using REALbasic as a vehicle for learning to program, or if you have never taken a full computer science course and you'd like to improve your programming skills, check out the Curriculum Project that I wrote for REALbasic. It's a good basic computer science curriculum in thirty lessons, available from the REALbasic website (www.realbasic.com).

A really important thing right out of the box: the REALbasic documentation is actually fairly good, and certainly better than I've seen for many programming tools.

There is a built-in reference that's almost always accurate and sufficient -- once you get up to speed, this is mostly what you'll refer to. There are also a Quick Start and Tutorial, which are fine as far as they go, which isn't very far. There's a User's Guide (a quite good, more extensive and useful introduction) and a Language Reference (a printable version of the built-in help). There are also a bunch of smaller ReadMe files on such things as database and Internet capabilities. These are concise and accurate, but far too short. Quite a few of these subjects, (and other subjects that for some reason don't even earn a README, such as 3D graphics), could do with extensive guides in their own right.

The Integrated Development Environment in REALbasic is quite effective. Not the world's most glamorous, but it strikes a nice balance between simplicity and power. Figure 1 shows the IDE in action.

This is great at 1600x1200, but it can get a little crowded on my 12" PowerBook's screen. On the other hand, I've never seen a development environment that didn't (okay, other than Emacs...).

Most of the action will take place in the window editor and the code editing windows.

The code editing window isn't the fanciest I've seen, but it gets the job done without fuss (Figure 2).

You get one code editing window per class/window/module, combining a simple inspector for all the attributes of that thing on the left, with the associated code editor on the right. The code editor provides comprehensive keyword completion (picking up declarations as they are made, and properly respecting scope), automatic coloring and indentation, along with gobs of little niceties like fairly comprehensive contextual menus, window splitting, and universal drag and drop. I find the relatively spare and uncluttered interface refreshing compared to many others -- have you looked at the Visual Basic IDE recently? Ugh.

REALbasic clearly tries hard to help you create a full-blown user interface. It has a great window editor that uses automatic snapping according to Apple's User Interface Guidelines (snapping to distance between controls, distance from window edges, and to the center lines of the window) to make user interface design almost effortless. Figure 3 shows REALbasic's comprehensive collection of user interface widgets.

The most interesting widgets here are (top to bottom):

• a Placard control, specifically for building the little information panel to the left of the horizontal scroll bar in a window (actually quite a nice contribution to making an effective user interface easy to throw together);

• a BevelButton control, used for making the kinds of new-fangled buttons all the kids are using these days, combining any or all of text, pictures and pop-up menus;

• a fairly sophisticated spreadsheet-like ListBox control;

• a cool 2D animation SpriteSurface control;

• an even cooler Rb3DSpace control, able to employ a pretty healthy set of OpenGL 3D graphics features;

• a QuickTime movie player;

• Windows OLE container support (for Windows applications, of which more below);

• Mac OS X toolbar and attendant buttons;

• a couple of widgets that take a little of the pain out of doing database interfaces (more below);

• a QuickTime music player; and

• Contextual menus.

As well as the user interface controls, REALbasic lets you fairly easily create OS X sheets, drawers and even Apple's new, hideous metal windows, along with the full complement of (in many cases, even more hideous) OS 9 window styles.

Oh, and there's a nice menu designer and a very nice event- and class-based way of managing menus, which let you either centralize the menu activation and handling, or distribute the handling around whatever points in the program you feel is appropriate. A good example of the numerous sweet design choices that make REALbasic either very beginner-friendly and straightforward, or surprisingly deep and powerful, depending on how you use it.

All in all, REALbasic couldn't do a whole lot more to help you to create a slick user interface.

REAL Software is testing a major new feature in 5.5: the REALbasic Project Manager. This is a simple server to synchronize the work of multiple developers. It provides accounts for multiple developers, and a simple check-out/check-in/synchronize capability for local copies of a project. It's a welcome feature, and I hope they continue to develop it with such features as history and rollbacks. It would also be nice if the check-out/check-in system offered an alternative CVS-style differencing model as an option.

REALbasic draws heavily on Visual Basic, to the extent that REAL Software supplies a free Visual Basic converter: a project converted from Visual Basic will still need some work before it's functional, but much of the code in a typical Visual Basic application will work exactly the same in REALbasic. I've heard of a few quite complex VB projects converted to REALbasic in just a few days.

The Visual Basic language (Visual Basic was bought, not invented, by Microsoft, by the way) is a generic, friendly, predictable, structured programming language. Having this language at its heart, REALbasic nicely satisfies the principle of least surprise -- things mostly just work the way it seems they ought to. Here's a bubble-sort algorithm:

A bubble sort in REALbasic

The heart of REALbasic is the Visual Basic language -- a nice, generic structured programming language

//Sort a list using a BubbleSort.
   Dim Done As Boolean
   Dim Counter, Temp, Limit As Integer

   Limit = UBound(Numbers)
   Do
      Done = True
      For Counter = 0 To Limit - 1
         if Numbers(Counter)>Numbers(Counter + 1) Then
            Temp = Numbers(Counter)
            Numbers(Counter) = Numbers(Counter + 1)
            Numbers(Counter + 1) = Temp
            Done = False
         End if
      Next
      Limit = Limit - 1
   Loop Until Done

But REALbasic's programming language is far from being a slavish copy of Visual Basic. The language extends Visual Basic into a grown-up object-oriented programming language, mostly by adopting the single-inheritance-plus-interfaces OOP paradigm of the likes of Java.

• Traditional method overriding. REALbasic also supports a novel and marvelous class extension mechanism called Events (more on that below);

• Single inheritance, with interfaces;

• Method and operator overloading;

• Simple compiler conditionals (so you can compile, say, different code for different platforms. There are no macros, though);

• Robust, typed exceptions with a full try-catch-finally-end try block (added in 5.5 -- earlier releases only had exception catching at the end of a method);

• Comprehensive safety checking (array out of bounds, nil variable dereference, and so on), with the ability to disable any of the safety checks in particular parts of the code, for speed;

• "Bare" methods and properties (having global scope, and not being part of a class);

• Simple namespaces (in 5.5);

• Public/Protected/Private scope (expanded in 5.5 from Public/Protected) for methods and properties;

• Separate scalars and objects, as in Java (many would consider this a mis-feature) -- and no sign of auto-boxing (automatic conversion of scalars to objects and back);

• A complete set of basic math operations, including bit operations, and even quaternions (no complex numbers, though -- the quaternions are provided for 3D math);

• The ability to define your own "bindings" for classes, that support connecting objects together in the user interface by just dragging a line between them, much as you can in Apple's Object Builder;

• "Getter" and "Setter" methods invoked through direct property access syntax;

• Latently-typed (good) automatically type-converted (bad) variants, just like in Visual Basic.

Conspicuously absent from the list are any real introspection features, serious modularity support, or classes as first-class objects in their own right, with their own methods, properties and events. These are significant omissions from an otherwise robust object-oriented programming language.

There are one or two ways in which REALbasic's designers have been prepared to develop creative new contributions to REALbasic's programming paradigm. One in particular, which goes by the everyday name of Events, is a marvelous idea that I've never seen in any other programming language. I'm going to unpack this for you, because it's an important language feature you won't be familiar with, and because I think more programmers should see this idea.

Events in REALbasic provide a top-down class extension model, by which a superclass can declare an API for delegating to its subclasses. Rather than a subclass just overriding its superclass's methods willy-nilly, in REALbasic, the code in the superclass can explicitly issue calls to code declared in its subclasses. This will very often significantly simplify maintenance, because if you need to modify the superclass, you generally know what the subclasses will do as a result. Once you get used to it, explicit communication between parts of the class hierarchy just feels right.

Here is an example of an abstract superclass and a concrete subclass, using events. This code implements part of a collection of character streams.

The example shows a method calling a New Event. New Event declarations take exactly the same form as interface declarations, which is more or less what they are. A New Event specifies a sort of internal API that code in subclasses can provide hooks for. Code in the parent class can then invoke any of its New Events in exactly the same way that it invokes a method. The parent class doesn't need to know any details of what the subclass code does in response to the event, or where, how or even if the event is handled; it just "delegates down". In the example superclass, all of the methods are nothing more than one-liners that immediately invoke the corresponding event. This is the standard way to implement an abstract base class in REALbasic.

Figure 5 shows a concrete subclass of the previous class that provides its characters from a text file. The screen shot shows code in one of the event handlers. Most of the code in this class is in its event handlers, but it also adds an extra method to set the file the instance of this class will read characters from.

It is possible for a chain of subclasses to contribute to the handling of an event. It is not required that a subclass provide a handler for an event it inherits. Rather, the most immediate subclass that declares a handler for an event 'swallows' the event, blocking 'lower' subclasses from seeing it. But the subclass with the event handler can, in turn, re-declare a New Event with the same name and arguments, and delegate further opportunities for behavior down the line. It can also define and call entirely new events, thus presenting a richer or modified set of behaviors for subclasses to extend further.

Events can be either method-style or functional (returning a value). A call to an unhandled method-style event is just ignored; calling an unhandled functional event returns 0, an empty string, Nil or the like.

The built-in REALbasic classes use this paradigm for extension, and it is quite easy to implement, say, a subclass of the built-in text editing class that only lets the user enter numbers, but otherwise works the same, including invoking the same event handlers on any further subclass, in case such a subclass needs to modify this behavior further.

It's a demonstration of the clarity events bring to inheritance that one can almost always just take one event-based inheritance chain, "paste it" at the bottom of another, and it just works. It almost seems as though this ought to make possible a form of event-based multiple inheritance in REALbasic.

One of the built-in classes is the Canvas control. This is essentially an empty control, providing a graphics space into which a subclass can draw, and providing every conceivable kind of user interface event for the control to respond to. It is fun to take this blank slate and implement an interesting user interface control with its own display capabilities, events and methods for further subclasses to draw on.

The event-based inheritance paradigm is, in short, a delight.

It is possible to drag classes, class hierarchies and modules from REALbasic out to the file system and into another project, including doing so as a soft "link" to the file (so the project automatically re-imports the file on launch, and any changes to the class are written out to the external file -- great for classes shared between projects). These exports can be encrypted if you wish to make them available without revealing the source code. You can also choose which of their properties can be set in the IDE, if an instance of the class is dragged into a window.

However, multiple classes -- even in the same hierarchy -- have to be exported as separate files, and have to be dragged into another project in a superclasses-before-subclasses order, or things break. This is just stupid, has been there since day one, and shows no sign of being fixed soon.

I would really like an ability to bundle up a class hierarchy and export it as one object. And it's a pity I can't set a project to automatically keep its entire contents as separate files, so I could use, say, CVS to manage the project (but see the discussion of the Project Manager, below).

REALbasic also provides a decent API for writing your own plug-ins in C. Unfortunately, the documentation for this hasn't kept up to date with changes to REALbasic. The documentation discusses making old-style resource-based plug-in using CodeWarrior on a Mac. The only deference to new features that I could see was a change history, and a brief mention in the READMe that old-format plug-ins should be converted to the current format using a supplied utility.

I understand that it is possible to author Windows plug-ins using Visual Studio, but this is essentially undocumented. You can work out how to do it by looking through the mailing list archives and asking the right questions, but the documentation here really needs to be fixed.

Another relatively unusual language feature: REAL Software developed the new compiler they introduced in 5.0 by first developing "RBScript", which is essentially the REALbasic language compiler, without all the hooks into the IDE and the toolkit. This has been developed into a built-in, compiled scripting language. The language is by default completely sandboxed -- it can't access anything outside itself. The developer can attach one object to the RBScript before compiling and running it, and the methods and properties of the object are available as globals in the script. So you can un-sandbox any capability you wish, and you can provide selective access to the rest of your application quite easily. Since it is also possible for the application to "covertly" put extra code at the top of a user-supplied script, providing an arbitrary number of ready-made classes and other features, it is entirely possible to create an arbitrarily full-featured scripting environment for a compiled REALbasic application, with comparatively little effort. This is a great feature, and I'm itching to try a project where I put a lot of, say, business logic into RBScript -- I could even keep the code in a database, or make it downloadable. Used effectively, RBScript could make a widely-deployed application unusually easy to support, upgrade and customize.

REALbasic's debugger is decent, but nothing amazing. It offers the standard click-to-put-a-breakpoint in the left margin of the code editor, but no easy way to find or temporarily disable the breakpoints you have. No conditional breakpoints (although in 5.5, you can issue a Break command to activate the debugger, so you can do whatever you like with that).

Once you fire it up, the debugger is straightforward and effective (Figure 6).

The debugger covers the basics: you can see the stack, your local variables, and globals. You can step over/into/out. A nice touch is that you can set the debugger to automatically activate when any exception is raised.

When you click on a variable in the locals pane on the right side of the debugger, you get a nice little inspector (Figure 7), and by clicking on object references (to open a new inspector on that object in a new window), you can drill down through a data structure as far as you'd like. A little difficult to see the whole data structure that way, but not bad. You can also modify scalar values while the program is running.

For 5.5, REAL Software is testing remote debugging. This makes it possible to debug a program running on one computer, from another computer, even running the debugger on a different platform to the one the program itself is running on, or running the debugger remotely, via the Internet. This is a marvelous feature, and I hope it makes the cut for 5.5.

Don't look for automated profiling, because there isn't any. It's understandable, with the focus and style of REALbasic, but I think one of the best features a language can have is a good profiler, and I hope REAL looks into this before too long.

Seriously missing in action is any means of browsing the class hierarchy. I find it hard to believe that I can't open a window and see a tree of the classes and subclasses in the program. Finding where you are can be a significant problem in a complex program.

5.5 adds a contextual menu choice that takes you from a method call to its definition, so at least there is a little progress on this front.

While REALbasic's "batteries included" don't approach those you'll find in, say, Python, you will find a very respectable and rapidly expanding collection of ready-to-go features "in the box". I'll discuss a few of the most important features below, but here is a quick list of some other major features:

• A fairly extensive set of Apple Event sending and receiving capabilities;

• Extensive vector drawing primitives (including Bezier curves, rotated objects and text, grouping, and employing bitmapped images as part of a vector drawing);

• Fairly extensive bitmap manipulation primitives (through either Quartz -- pretty! or QuickDraw -- fast!);

• QuickTime editing of movies in code (surprisingly complete, including access to QuickTime effects);

• Complete file system access, including random-access read-write files, sequential access to files, getting and setting file and folder properties, and access to Resource Forks;

• Full access to the keychain and the clipboard (apart, oddly, from being able to find what arbitrary types of information are on the clipboard);

• A fast, raw MemoryBlock object type;

• A 3D sound class, with quite rich capabilities drawn from QuickTime;

• Access to the Registry (on Windows);

• Sending and receiving Apple Events;

• Straightforward multi-threading (sadly, only on one processor), with semaphores and critical sections;

• Ability to control a shell, on both OS X and Windows (strangely, though, no support for StdIn, StdOut, or StdErr);

• Comprehensive POP/SMTP Email sending and receiving, including with SSL (in the Professional release);

• HTTP (with SSL, in the Professional version) protocol support for sending and receiving;

• Regular Expressions (but not as part of the language -- this is a set of classes you have to instantiate, set properties on, and invoke -- so not remotely as convenient as in, say, PERL);

• Fairly thorough support (I understand -- my language skills are limited to the Roman alphabet) for text encoding and Unicode.

REALbasic's database capabilities are quite decent on the whole, although some gaps in the "batteries included" are disappointing. Also see Printing, below, for a more serious obstacle to database applications.

REALbasic includes plug-ins giving support for a nice range of common databases:

• ODBC;

• PostgreSQL;

• MySQL;

• 4th Dimension Server;

• OpenBase;

• FrontBase;

• Sybase

• Comma-separated files;

• .dbf (dBase) files;

• dtf;

• Oracle.

REALbasic also includes a plug-in for a competent basic single-user proprietary database format.

For databases not supporting SQL directly (most notably, the built-in database and 4th Dimension), REALbasic provides an interpreter for a useful-but-small subset of the SQL language.

There is also a very good-looking third-party database plug-in available called Valentina that seems to be getting a lot of attention in the REALbasic community.

All of the database connections share their more important methods and properties and have a common base class, so to the extent that your SQL code is portable between databases, your REALbasic application can be switched from one type of database to another quite trivially.

Access to the data is through a standard cursor-type object. Some standard special-purpose interface controls and some special features of some of the general-purpose controls (such as the EditField and the ListBox) make it quite easy to put together a basic interface to scroll through a list of records, double click a row and go to a detailed view of a record, update fields, click through records one at a time... The automated features don't get in the way of doing some of the work yourself should you need something out of the ordinary. Also, insofar as you can do your data manipulation through the one-record-at-a-time cursor, you can make your code even more independent of the particular underlying database.

I wouldn't say that a REALbasic database user interface is remotely as quick to set up as, say, a FileMaker interface. But it's a couple of orders of magnitude more flexible without being anything like that much more work.

On the other hand, if you want to develop a GUI database application of any complexity, you'll probably need some user-friendly query, import/export or customizable reporting applications, and REALbasic doesn't come with anything like that. REALbasic provides everything you need to write those from scratch, but doing a good job of these kinds of applications would be a serious effort.

Plug-ins may help here. I've heard nice things about dbReports (http://www.abdatatools.com/dbrIndex.html), for user-customizable reports. There may well be similar alternatives for the import/export and querying, but after spending some time googling for them, I came up short. More on plug-in availability below.

Sadly, REALbasic doesn't take the opportunity to provide an object database, or anything else to help bridge the object-relational divide.

Far and away, the biggest problem you'd have doing a significant database application (or, indeed, many kinds of programs) in REALbasic is printing.

REALbasic provides only very low-level, QuickDraw-like printing capabilities. To print from a REALbasic application, you get a special graphics object into which your code draws, then you print it when you're done.

The graphics drawing features of the REALbasic language provide good basic capabilities for this -- you can ask REALbasic to draw a string or styled text into a box of a certain width, and it then tells you what height it was, for example. But doing any kind of complex report in code like this is intractable for the upwards of hundreds of reports you might have in a typical bespoke database application.

It's a great shame, too, because REALbasic would otherwise be excellent for such development. This is far and away the most serious hole in REALbasic's feature set.

I understand that REAL Software is working on a new printing capability, but it's not looking like anything is going to appear in 5.5, at time of writing.

Relatively unknown fact: Microsoft's Mac development team used REALbasic to prototype the user interface for the last version of Internet Explorer for the Mac, and they continue to use REALbasic, even publishing at least one part of the last version of Office written in REALbasic (below).

It also appears as though Microsoft are working with REAL Software on a Microsoft Office automation plug-in for REALbasic. The feature isn't absolutely complete yet (particularly lacking the ability to trap events in Office applications), but it can probably do anything you're really likely to need -- the examples for the Plug-ins create and modify a Word document, create a PowerPoint presentation, import a picture into PowerPoint, and create an Excel spreadsheet. The features already available can do most of what you are likely to need (automated creation of pretty reports, slideshows and spreadsheets from REALbasic).

The code is also fairly straightforward.

REALbasic code to create a Word document
It is fairly straightforward to use the Office Automation plug-in.
Sub Action()
dim word as wordapplication
   dim doc as worddocument
   dim style as wordstyle
   dim v as variant
   
   word = new wordapplication
   doc = word.documents.add
   doc.range.text = editfield1.text
   
   v = doc.paragraphs.item(1).style
   if v.objectvalue isa wordstyle then
      style = wordstyle(v.objectvalue)
      styletext.text = style.namelocal
      stylefontname.text = style.font.name
      stylefontsize.text = str(style.font.size)
   end if

exception err as wordexception
   msgbox err.message
End Sub

One very nice feature is that the same code should work on both Macintosh and Windows (modulo some features that, at time of writing, had not been implemented on the Mac yet).

Sadly, as with a few of the most interesting features of REALbasic, the documentation is woefully incomplete. A terse README or two and a few very simple examples constitute all the documentation I'm aware of. I think the REAL Software folks are expecting the developer to look to other Visual Basic for Applications documentation to fill in the blanks here (the plug-ins exploit REALbasic's similarity to Visual Basic to re-implement virtually the same API). But it would be nice if, at least, they pointed the user to a good source for this information.

Note that you can also exercise extensive control over a huge range of Macintosh and Windows applications using Apple Events, AppleScript (below) or OLE.

A great feature is that you can compile an AppleScript method, drag the AppleScript file into REALbasic, and just call it from your REALbasic code, no other work required. This is a heck of an integration feature, a very quick and easy way of talking to all sorts of applications, and a very nice way of putting a user interface on an AppleScript.

On both Macintosh and Windows, it is possible to access toolbox calls. Enough low-level bit-wrangling features are available (including being able to do things like get handles for REALbasic windows) that you can access most toolbox features if you know what you're doing. And if you don't, this feature is the basis of a lot of cheap-or-free classes providing access to most OS features that aren't already covered by REALbasic.

On Windows, you can also call into DLLs, and in 5.5, REAL is testing callbacks into REALbasic methods for both Macintosh and Windows.

REALbasic is becoming one of the best ways around to write cross-platform code. There is a functionally equivalent IDE for Windows, and you can compile to Windows on the Mac or vice-versa (with the Professional version). The integration with Windows isn't as complete as is the integration on the Mac, but it's pretty decent. In particular, the most important piece, being able to use OLE plug-ins, is there.

For 5.5, REAL Software is beta-testing a Linux compile. In developing their Windows version, REAL implemented compiling for Windows on the Mac in early releases, following in later versions with the Windows IDE. This is almost certainly what they're doing for the Linux transition, which targets GTK. Once they get the kinks out of the Linux compile, REALbasic will have a good claim to being the best cross-platform GUI development story around.

REAL Software is a pretty pleasant company to deal with. They have a couple of very active developer email lists (one for the regular release, one for the betas), as well as a few other lists for the likes of beginners and game developers. Virtually all of the REAL Software staff post on the email lists from time to time, and many of them post just about daily, including the president of the company, and all the developers.

REAL Software is very open with its development process, putting regular development releases out for general consumption, testing and debate. And they're very good-humored about the inevitable problem with such a development strategy: people complaining, sometimes bitterly, about bugs in alpha and beta software.

They also have an excellent bug tracking and feature requesting system, in the form of a web-accessible database. You can add to it only after first searching for an existing report, and you can add comments to an existing report or "vote" on it, adding your weight to the need to address the report. And REAL does seem to try fairly hard to address these things in order of popularity.

There is a developer's program offering several tiers of membership, providing such things as expedited support.

REALbasic boasts a helpful and robust community, focused on the mailing lists. There are also a great many web sites concerned with REALbasic, several books, and quite a few developers sharing all manner of code, tutorials, plug-ins and other tools.

On the other hand, there is no CPAN-type code library for REALbasic. Partly, this is the language design that doesn't (yet) provide the sorts of features you'd need to really easily share code (I'm thinking particularly of a real modules and namespaces feature -- some of the new features in 5.5 are a good step in this direction). But none of that is a show-stopper -- it could still be easier to find plug-ins, for example.

There is one site, rbgarage.com, that is clearly aspiring to be a CPAN for REALbasic. It's a nice site, clearly someone is putting in some effort here. It remains to be seen whether they will get the momentum going to become the kind of canonical point-of-origin that CPAN is, but I wish them well.

I always like to find out what real projects have been written with a programming language. Without further ado:

• Art Directors Toolkit, a designer's toolkit, which Apple bundles with all PowerMac G4 Towers and Powerbook G4 Laptops.

• Microsoft Query for Mac OS X, which uses Open Database Connectivity (ODBC) to allow you to import data from databases into Microsoft Excel X.

• Auto-Illustrator, an "experimental, semi-autonomous, generative software artwork and a fully functional vector graphic design application to sit alongside your existing professional graphic design utilities".

• Whistle Blower, a server monitor and functional testing utility.

• Intellimerge, e-mail merge software for Mac OS X and Mac OS 9.

• Coldstone Gaming Engine, an easy to use game development tool that allows you to create professional stand-alone games that run on Mac OS, Mac OS X, and Microsoft Windows.

• A-OK: Wings of Mercury, a realistic simulation of the Mercury spacecraft.

• SpamFire, An anti-spam email filter.

• MediaEdit, a movie and graphic editing tool.

REALbasic comes in two versions (Standard and Professional) for two platforms (Macintosh -- Native and Classic, and Windows).

The extras in the Professional version are:

• Cross-platform compiles;

• The database features;

• SSL for the Internet features; and

• a better "server" version of networking sockets.

In the US, at time of writing, a Standard version can be had for $99.95, and Professional for $399.95. That's for the download-only version. A little more gets you over 1000 pages of dead tree documentation and a CD. There is also a somewhat more expensive version that gets you a year of upgrades.

Upgrades from the previous version are $79.95 (Standard) and $169.95 (Professional). If you're serious about REALbasic, the subscription is a non-trivial saving on the upgrade.

There are also some Academic pricing options, volume purchase options, and the like.

You could call high-level languages an obsession of mine. I've tried many, many languages. Compared to REALbasic, I've tried Deeper languages (Scheme, Dylan), more broadly accepted languages (C++, Python, PERL, ...), languages that are easier to use (Python), and languages with better IDEs (Java with Eclipse or Objective C with Project Builder).

But I've not used any language or IDE that makes good GUIs easier to construct than does REALbasic. That would be a great argument for REALbasic on its own, but the clincher for me is that REALbasic scores a consistent "really, pretty decent" on depth, acceptance, ease of use, and the IDE -- something I wouldn't say for any other language I know.

REALbasic is an effective tool for either beginners or experts and it's fun to work with. As long as its one really major limitation (printing) isn't a problem for you, it's a good candidate for a very broad range of development projects.

Guyren G. Howe works in artificial intelligence research, after years of work as a technical writer and developer. He is married with one child, is an Australian, and lives in Austin, Texas. Guyren has been working with REALbasic for several years. Most notably, he wrote the REALbasic Curriculum Project, an extensive computer science curriculum, for REAL Software.