When programming on the iPhone, for example, you may place a UITableView into the window.  This would be like placing a Listbox onto a REALbasic window.  In REALbasic, you actually are creating a subclass, named Listbox1 by default.  In Cocoa, however, you’re placing a UITableView object onto the window.  So, how does loading the data into the “list” differ between Cocoa and REALbasic?  Well, in REALbasic, since you have placed a subclass into the window, you simply respond to the necessary events, and call methods such as AddRow on the Listbox subclass.  In Cocoa, you assign a “delegate” object which will respond to several messages sent by the UITableView when it needs to load data.  The UITableView will “ask” the delegate how many rows of data there will be in the list.  Then it asks for enough data to fill the visible area of the list.  The benefit to this model is that the list only needs to be populated with enough data that can actually be seen.  In REALbasic, you must add all the data to the list, even if the data will never be seen by the user.  This can waste processing time, which can cause the user experience to be slow and non-responsive.

How can you fix this then?  You could use Interfaces to create a delegation model, but then the object which is acting as the delegate would need to specifically implement the entire interface.  In Cocoa, you can choose to implement at least the “required” methods and several of the “optional” methods.  REALbasic doesn’t have an “optional” way to implement methods.  Sure, you can just choose to fill in only some of the interface methods, but that means that you have to go through the process of choosing, ahead of time, to implement the interfaces.  That also means that your code is not as separated since the interface must be explicitly declared and the implementor must explicitly implement the interface.  It isn’t as “dynamic” as the Cocoa methodologies.

So, we can mimic the loose binding of methods by using the “Extends” keyword, and then optionally implementing the methods in various objects.  Look at this Module:

Module MyOptionalDelegateModule

Function numberOfRowsInTable( Extends tableView As Object ) As Integer

// Do nothing here except return a “default” value

Return 0

End Function

End Module

Now, in your “pretend” delegate object, you can declare this method:

Class MyDelegateObject

Function numberOfRowsInTable() As Integer

// Here do the actual work

Return 5

End Function

End Class

Now, you could create a custom listbox which asks a “delegate” for some number of rows.  You can assign any object as the delegate, even if it doesn’t implement “Function numberOfRowsInTable() As Integer” because the implementation in the module will be called.  If the object does implement the method, its implementation will be called instead.  So, you can define a bunch of methods and attempt to call them, and if the object actually implements the method, you’ll get the customized behavior.

So, if you like the delegation design pattern in Cocoa, you can now mimic it using the Extends feature of the REALbasic language.  Protocols can already be mimicked simply by defining an Interface.

The forms for creating methods, properties, etc. really can be a time saver, but it isn’t the only help the IDE provides.  One of the best ways to produce more correct code is a proper auto-completing code editor.  REALbasic’s is one of the best I have ever used.  While some editors will help you type common keywords and previously-typed words, the REALbasic IDE will provide methods and properties that make sense to the context of the code.  Since the REALbasic IDE knows your code and project structure, the suggestions are often more accurate than some other IDE’s.  I recently used NetBeans IDE for writing Php code, and the auto-completion often just wasn’t able to recognize the context of the code in order to produce a valuable auto-complete suggestion.  Many of the most modern IDE’s are improving their code-completion, but I believe that REALbasic was far beyond the others much earlier.  As the REALbasic IDE improves, I look forward to seeing even more accurate code-completion to help me code much faster.

Building projects quickly is another area that REALbasic excels.  Since the REALbasic IDE is responsible for project structure, code and user interface, an application can be built in record time.  When you launch the REALbasic IDE, you’re started off with a brand new project that is already setup with the basic components that most applications need.  All you have to do is add a button and tell it what to do.  Even when I’m not working on an active project, I have jumped into REALbasic many times to whip up a quick file convertor or some other helpful automation.  Better than most of the “automation” software available, REALbasic can be quickly built to create any helpful tool in a matter of minutes to hours, rather than what could take days.  The rich framework also helps in rapidly creating utility or productivity applications since most of the routine functions are wrapped up into convenient classes and modules.

REALbasic provides more than just an alternative programming environment for new programmers and hobbyists, it provides a rapid application development environment that helps you speed up the process of building valuable applications in record time.  One of the key ways it does this is to help you write correct code quickly in a managed environment called the REALbasic IDE.

Now it has been a joy for me to go through all my old projects and bring them up-to-date with the current REALbasic 2009 Release 2.1.  I’m excited about the progress that has been made, and my applications seem to immediately benefit from all kinds of performance increases and improved user experience.  It is easier in REALbasic 2009 Release 2.1 to build platform-native applications than it has ever been, which allows for a quick and easy transition path for all my old projects.

REAL Software is bringing the fun back to programming as they continue to improve the development environment that we have all come to enjoy.