Volume Number: 16 (2000)
Issue Number: 5
Column Tag: Programmer's Bookshelf
By Paul E. Sevinç, Switzerland
REALbasic is an integrated development environment (IDE) from REAL Software, Inc. [3]. In the last couple of months, REALbasic was the topic of several MacTech articles written by Erick Tejkowski [4, 5, 6, 7]. For an overview of REALbasic, please refer to Erick's second article [5] or the REALbasic home page [3].
Written by Matt Neuburg and published by O'Reilly, REALbasic: The Definitive Guide [2] describes the higher edition of REALbasic version 2. But as targeting Windows is not covered, most of the text applies to the standard edition as well. Matt Neuburg is a past editor of MacTech, by the way, but this shall have no influence on my review.
The book is divided into three parts of about 210 pages each: Fundamentals, User Interface, and Reaching Out. Please note that unlike the first two parts, I haven't read the last part in its entirety (i.e., in number of pages, I have read about a third). Note further that I have never dealt with REALbasic prior to reading this book.
Chapter 1, The Workspace, and chapter 2, The Basic Language, introduce the REALbasic IDE and the REALbasic language, respectively. The explanations of the language constructs might be too terse for novices at programming. For everybody else, however, the concise writing allows for a quick transition to REALbasic without being boring or superficial. What irritated me a little at the beginning is that some names are capitalized differently in the code examples and in the main text. (REALbasic is case insensitive.) And Neuburg's definition of "side effect" is somewhat sloppy. Nevertheless, after two chapters only, I gained the impression that he is a pretty good teacher and writer.
Chapter 3, Objects, Classes, and Instances, and chapter 4, Subclasses, introduce object orientation in the context of REALbasic. These two chapters risk to frustrate novices at object-oriented programming (OOP): while a lot of concepts are explained in a very intuitive manner, non-trivial examples in which OOP unleashes its power are lacking. Beginners must be aware of this. After all, it is only natural that there are trade-offs when a book treats a language, a paradigm, an IDE, and a framework. Alas, Neuburg's treatment of interfaces may leave a wrong impression, namely that they are primarily a means of fixing class relationships or of supporting so-called binding. Yet every experienced Java programmer will confirm that single implementation inheritance with multiple interface inheritance allows for very clean and powerful designs.
Chapter 5, Datatypes, discusses elementary REALbasic data types, such as booleans, strings, and dates, as well as two classes that support low-level memory handling and threading, respectively. In the section on numbers, Neuburg uses the terms "binary", "octal", and "hexadecimal" without explaining them anywhere in the book. This (and what I said about novices in the preceding two paragraphs) leads me to the following question: Who is the target readership of the book in the first place? (On the cover it says "Macintosh programmers at all levels" and in the preface "this book does not teach you to program the Macintosh".) If it includes beginners, some sections of the book need to be elaborated. If not, some sections are not necessary (e.g., on what flow control is).
Chapter 6, Menus, shows how menus and menu items are created, how they can be enabled and disabled, how the application reacts to a menu item being chosen, etc. I particularly liked that it includes a section on dynamic menus with typical examples (Font menu and Windows menu). And chapter 7, The Architecture of an Application, gives some tips concerning REALbasic-based applications. It does not discuss architectural issues in general, however. (See, for instance, Buschmann et al. [1] for more on this topic.)
Chapter 8, Debugging and Building, concludes the first part. It explains how to read compile-error descriptions, REALbasic's exception handling, how to use the debugger, and the application build. After the first three pages in the section on exceptions, I was going to say that Neuburg chose a poor first example to illustrate them. Because it catches an exception caused by an error that can be fixed during development and that does not depend on the time & space in which the final application runs (e.g., on a computer with an unreliable hard drive). However, I then saw that four of REALbasic's five (or six) RuntimeException subclasses are about such errors, so that Neuburg isn't the one to be blamed. Nevertheless, he should have said more than just "Most of the time, you'll probably try to eliminate runtime errors from your program in advance" [2, p. 206].
The first ten chapters of the second part cover graphical user interface (GUI) elements, the remaining two discuss the keyboard and the mouse. As is stated in the preface, the Human Interface Guidelines are not a topic of the book. Many different GUI elements are explained, such as windows, tab panels, sliders, etc. In addition to the default classes that REALbasic provides, Neuburg also presents subclasses and helper classes developed by him and others. Furthermore, a few advanced examples are also included. What I liked a lot is that Neuburg warns against bugs or limitations he encountered and tells the reader what to do about them.
To cut a long story short, this part is likely to contain valuable information about the GUI element the reader would like to employ. And in case the GUI element is not available or does not behave as desired, several ways to create a custom GUI element are shown as well.
Chapter 21, Files, covers many file-related issues: creating and deleting files, navigating the file system, reading and writing the data or resource fork, preferences and temporary files, etc. The concept of file type and file creator is briefly explained, the difference between data fork and resource fork not really. Overall, however, the level of detail and the examples are very good. Particularly cool is that some of the example tasks - copying, for instance - are not only solved with REALbasic classes, but also with AppleScript scripts imported into the REALbasic project.
Chapter 29, Printing, is rather short, which-considering its importance-is a pity. Apparently that's because "Support for printing in REALbasic is rudimentary" [2, p. 555]. So, after a few tips, the reader is left to her own experimentation.
Chapter 31, Apple Events and AppleScript, first briefly introduces Apple events and AppleScript and then discusses Apple events and the REALbasic classes that support them in quite some detail. This chapter teaches how to send and receive events in order to make an application scriptable, and how to execute scripts from within an application.
To give you an idea of what other topics the third part includes, here are the titles of the remaining chapters (that I haven't read): Databases, Clipboard, Drag-and-Drop, Time, Sound, Movies, Game Animation, TCP/IP Communications, and Language Extensions.
Despite some shortcomings, Matt Neuburg's excellent writing and its broad range of topics make REALbasic: The Definitive Guide an easy-to-understand and very useful book for programmers entering the world of REALbasic.
In my opinion, the book is best suited for programmers with experience in OOP. Other programmers should do just fine, too, even though their perception of object orientation will probably be somewhat limited. For a complete novice, however, this book alone is not enough to get started.
What is clearly missing is an example application (e.g., a simple text editor) where different aspects such as menus, windows, files, printing, etc. could have been shown side by side. So feel free to develop such an application and to write about it in MacTech!
Paul recently earned a Dipl. El.-Ing. ETH degree, the Master's degree in electrical engineering from the Swiss Federal Institute of Technology Zurich (ETHZ). Now he hopes to finally find the time to finish Aho et al.'s Dragon Book. You can inquire on his progress at paul.sevinc@ubilab.org.
