There is a recent thread on the REAL Software forums asking why REALbasic isn’t more popular. I’d say one of the main reasons that REALbasic is not as popular as it could be is because of its name. I have high hopes for the new REAL Studio name. Unfortunately, when it comes to programming languages, the term Basic gets a bad rap. Even in the .NET world, where there is practically no difference between C# and VB.NET, there are lots of developers that turn their nose down on VB.NET and assume it is inferior.

The problem with Basic

Personally, I don’t think it’s possible to fix the perception problem with Basic. When you mention Basic, people still think:

10 PRINT "PAUL"
20 GOTO 10
RUN

Basic’s accessibility has always been considered a weakness by many who call themselves professionals. Because it is so accessible, just about anyone can learn enough to use it to make software. And if that software doesn’t end up being very good, people tend to blame the tool instead of the inexperienced programmer. But the accessibility of Basic is also its greatest strength. There are plenty of people who aren’t professional programmers but are experts in their business domain. These people can use a tool like REAL Studio to create simple application to make their lives easier. And if they need more sophisticated software, they can turn to us consultants that like to use fun, powerful tools such as REAL Studio.

I also feel that REALbasic’s popularity was also hampered by its name being a bad pun: it’s “real basic”. Lots of developers take that to mean “incredible simplistic and inappropriate for professional software development. They have no idea what the REALbasic language is capable of and have no interest in finding out. So they never learn that it is a fully object-oriented language that has far more in common with Java (or .NET) than any old-school version of Basic that they may remember. I truly hope that the new name helps improve this perception.

But even if the product is now referred to as REAL Studio, the programming language is still referred to as REALbasic. And it will take quite a bit of time before the new name is used consistently.

Two other products that I think compare well to REAL Studio are PowerBuilder and Delphi. Like the new REAL Studio branding, note that they each use separate names for the product and the programming language they use (Delphi/Objective-Pascal, PowerBuilder/PowerScript). You might also make the same case when it comes to Xcode and Objective-C. And most developers that use those tools refer to themselves as Delphi or PowerBuilder developers. So perhaps, given time, people will also stop referring to REAL Studio as REALbasic.

But even if that is the case, is REALbasic still a good name? I think that the REALbasic language has outgrown its “real basic” name. I first learned to program on an Atari 400 back in the early 80’s using Atari BASIC. I then migrated from that to structured Basics (such as GFA Basic), Pascal, C and on to a variety of programming languages. I was one of those that thought Visual Basic was a terrible language and thumbed my nose at it, although I may have been right about Visual Basic (before .NET anyway). These languages were all “real basic”.

But unlike any of the above languages, both REAL Studio and VB.NET (which Microsoft has taken to calling just Visual Basic these days) use a powerful, modern object-oriented version of Basic with a ton of sophisticated features (namespaces, instrospection, dynamic programming, delegates to name a few). For all practical purposes there is little difference between using them or using Java, C# or any other object-oriented language.

So even if the REALbasic language was once “real basic” it no longer is. I think the name ought to be changed, especially now that REAL Studio has become the product name. I suggest either choosing something meaningless and invented (like Ruby or Python; I suggest Bee) or something that truly describes what it is (like Objective-Basic¹ or Object Basic²; I suggest OObasic).

This does beg the question as to what those of us that use REALbasic or RB in our web site or product names ought to do? Does it make sense for me to rename RBDevZone to be RSDevZone? What about the Association of REALbasic Professionals (ARBP)? And REALbasic Developer Magazine? RBGarage?

How do you compete with Free?

Another complaint about REAL Studio that I hear often is that it is too expensive. Generally this is just not true because REAL Studio Professional and REAL Studio Enterprise both cost less than equivalent editions of Visual Studio, PowerBulder or Delphi. In the case of Delphi and Visual Studio there are free editions: Turbo Delphi and Visual Basic Express. And of course, Xcode is completely free for OS X developers. Microsoft also tends to make its developer tools very affordable (almost free) for startup companies.

I think it would be great for REAL could also offer a free edition of REAL Studio. Since I’m on a roll, my recommendation to REAL is that they offer REAL Studio Free Edition with the same features as REAL Studio Personal Edition except for one thing: it would be unable to compile independent executables.

I see lots of benefits to both REAL and the community with a free edition. For one, it will get a lot more people to try REAL Studio. Want to learn how to program? Use REAL Studio Free Edition. Schools could implement REAL Studio at no cost to teach programming. What a great way to get a ton of exposure! And getting students hooked on programming with REAL Studio has some major long-term benefits.

Even better, wouldn’t it be great if REAL Studio Free Edition was included with all new Macs, Dells and even Ubuntu Linux? Granted, it wouldn’t be free for REAL to do that, but think about how quickly it would increase the REAL Studio user base?

For the community, having a ton more people becoming aware of REAL Studio (and actually using it) would be a major boon. There would be more people creating sample code, more people to buy your add-ons and more people to request your consulting services. And for REAL, it means there would be more people that are now aware of REAL Studio and who might actually select it for their next project. I am sure this would lead to additional sales.

Lastly, this would be a fabulous way to promote the new REAL Studio name and finally bury the REALbasic name once and for all. There would be a ton of free press, publicity and overall good will that would be generated if REAL announced “REAL Studio Free Edition with OObasic”.

Anyway, those are my (highly opinionated) thoughts? What do you think?

² See Phoenix Object Basic.

You’ve all heard the news: Visual Basic is dead. Support for Microsoft Visual Basic 6 has pretty much ended and you will soon be completely on your own. Microsoft wants you to move to their powerful, but extremely complex .NET platform.

I can hear you all screaming “No!!!, say it isn’t so”. But it is so. So what are your options? The way I see it, you have these options:

1. Tough it out with Visual Basic
2. Switch to .NET
3. Switch to something else
4. Migrate to REALbasic

I’ll cover each of these options and hopefully convince that you should strongly consider REALbasic.

Tough It Out with Visual Basic 6

The easiest option is to just stick with the status quo and use Visual Basic as you have been for years. It’s worked this far, why not keep using it? Well, the world has not been standing still since Visual Basic 6 was released in 1998. Vista is out now and VB6 does not have any Vista support, although applications seems to work fine with it. For now. Mac OS X and Linux are also a lot more common now, which might be something you should consider.

The IDE UI for VB6 is also dated. It’s an MDI application with a bunch of Windows that are all over the place. Frankly, it is a bit ugly to look at:

And the VB6 language, although easy to learn, is also not all that powerful either. For one thing, its object-oriented capabilities leave much to be desired. It doesn’t have inheritance, for example. You’re forced to use interfaces to work around it.

If you stick with VB, where will you get your support? Microsoft ended mainstream VB support some time ago. You can still get some support from them for a few more months if you’re willing to pay for it, but after that you’ll be on your own.

I don’t think that burying your head in the stand and continuing with VB6 is a good idea.

Switch to .NET

Microsoft recommends you switch to .NET, so it must be the way to go, right? Don’t be too sure! If you have never worked with .NET, switching from VB will be a daunting task. The framework documentation is immense, so you’ll have a lot to learn. A printed copy of the .NET 1.1 framework reference guide is over 2 feet tall. .NET 3.5 is even larger! And don’t forget that Microsoft is rolling out changes to .NET at a furious pace. Visual Studio 2010 (with .NET 4.0) is now in beta and is scheduled for release in early 2010. Each of these new versions adds lots of new features and lots of complexity. It is hard to keep up.

Microsoft used to refer to the version of Visual Basic included with .NET as VB.NET. Now they’ve taken to just calling it Visual Basic. But even though it shares its name with Visual Basic 6, it is really an entirely new language and has almost nothing in common with VB6. The language features and object model are completely different. Microsoft does provide a migration tool, but it works about as well as any migration tool, which means “not well”.

And what about cost? Sure, Visual Basic 2008 Express is free, but it has a lot of limitations. You’ll probably want to shell out for at least the Standard edition ($257 from Programmer’s Paradise), but probably the Professional edition ($696 from Programmer’s Paradise).

Switch to Something Else
Of course, there are other choices as well. You could always give Delphi 2010 a try, but it’s $900 for the Professional edition. It’s also uses Pascal (albeit an object-oriented version). I liked Pascal in the 80’s, but who seriously wants to work with it now?

You could also consider Java (recently bought by Oracle), but if you thought .NET is complicated you’re in for a real treat with Java. The biggest benefits for Java is that nearly everything for it available for free. The biggest downside is that you’ll spend much more time and money learning how to use than you would have spent by choosing another option. And although Java is cross-platform, it takes a lot of work to create a UI that looks decent on multiple platforms.

Migrate to REALbasic

Now this just might make more sense! The REALbasic language should look quite familiar to VB programmers. It is a different, though fully object-oriented, language, of course, but it is very easy to see how things are connected. The REALbasic framework is well organized and easy to understand. It’s also concise, so you can learn it all in a short time.

The IDE works great with multiple tabs as you would expect any modern development IDE to do. Additionally, REALbasic is updated regularly (every 90 days, in fact). And these updates are small and focused, so you can stay on top of the changes.

And I saved the best for last: REALbasic is cross-platform! REALbasic itself runs on Windows, Mac OS X and Linux and can create applications that run on Windows, Mac OS X and Linux. You can do your development on whatever platform you prefer but deploy to the platforms your customers use. And since you’re coming from VB, which is Windows-only, you can also grow your customer base by branching out beyond Windows, which might be significant depending on what your application does.

Check out accompanying sidebar for more information regarding REALbasic and Visual Basic.

How to Get Started?

Hopefully, you have now realized that REALbasic ($100 for the Personal edition) is worth a look. If you haven’t already, download the REALbasic trial for your platform.

Eventually you’ll want the Professional edition ($300), though, since it has advanced features such as Container Controls and cross-platform compiling. New for 2009 is REAL Studio, which includes REALbasic Professional for all three platforms, additional support and a license to REAL Server (their SQL database server). At $1000, it is not cheap, but it does cost less than buying everything separately.

REAL Software also has a new tool, the VB Migration Assistant, available for free on their web site. This tool migrates your VB code and controls to REALbasic. The code itself is not changed (it simply migrates it as comments), but it is a great way to get your VB project into REALbasic so you can migrate it all in one place.

AYB Computers also makes a tool to help with VB migrations. Their product, VBConvert!, actually attempts to migrate all your code and controls. At $50, it’s worth the investment.

Realistically, if you have a Visual Basic application and are thinking it should be moved to REALbasic, then you need to do a bit of analysis first. No tool is going to magically make your VB project work 100% in REALbasic.

Ask yourself if your application needs to be an exact port or does it just need to replicate functionality? In many cases, you can create a much better design in REALbasic than you could have with Visual Basic because REALbasic is a much more powerful language with better object-oriented capabilities.

Does your application make use of many 3rd party controls and libraries? Not all of these will work with REALbasic, and even if they do they would prevent you from creating a cross-platform application. Think about what your using and why. Perhaps there are equivalent 3rd party controls available for REALbasic or perhaps you don’t really need them after all.

What’s Similar to Visual Basic?

As you might expect, Visual Basic and REALbasic have a lot of similarities.

Syntax
As you might guess since both Visual Basic and REALbasic have “basic” in their name, the language syntax is very similar. You’ll see familiar syntax for For..Next, While..Loop, If..Then..Else, Dim and many other commands. You’ll have no trouble at all reading (or writing) REALbasic code.

Data Types

Although REALbasic’s data types are not always named exactly the same as the Visual Basic ones, all the equivalent types are there. For example, the REALbasic Integer is equivalent to the VB Long (figure 3).

Controls

The default UI controls included with VB are, for the most part, also included with REALbasic (figure 4).

REALbasic also has several controls that are not included by default with VB (figure 5). Of course, there are plenty of available controls for VB that can be added to its default setup. REALbasic can use some of these 3rd party VB controls, but not all of them.

What’s Different from Visual Basic?

Of course, REALbasic also has quite a few differences from Visual Basic as well.

REALbasic cannot create DLLs, ActiveX controls or any kind of shared libraries. Since these are all Windows-specific technologies, that is somewhat understandable. You’ll either need to rethink your design here or just re-use these components from within REALbasic (and thus limiting yourself to just deploying on Windows).

As I’ve mentioned before, REALbasic is fully object-oriented. Unlike VB, you can have real classes with real inheritance and other object-oriented properties.

File I/O

One of the biggest differences between VB and RB is file I/O. REALbasic consolidates all its file processing into a few classes: FolderItem, TextInputStream, TextOutputStream and BinaryStream. VB uses hard-coded file paths and less flexible file access methods, primarily because it is Windows-specific. Any code that you have in VB that references files will need to be converted to use the equivalent REALbasic classes.

Data Types

REALbasic is strongly typed. Visual Basic allows you to do some things the “old-school” BASIC way, the most significant of which is using variables without declaring them. REALbasic does not allow this. Use the OPTION EXPLICIT command in all your Visual Basic code to have VB enforce explicit variable declarations.

Wrapping Up

I think I’ve given you a lot to chew on in this overview. Give REALbasic a try; you’ll be glad you did!

Figure 3: VB and RB Data Types

Figure 4: VB Controls and equivalent RB Controls

Figure 5: RB controls not included with VB by default

• DisclosureTriangle
• NotePlayer
• PagePanel
• Placard
• PopupArrow
• ProgressWheel
• Rb3DSpace
• RbScript
• Separator
• Serial
• ServerSocket
• SpotlightQuery
• SpriteSurface
• TCPSocket
• UDPSocket
• UpDownArrows

First, REALbasic does not have CallByName. However, it does have Introspection (aka reflection) which can be used to achieve this.

The official function definition in VB is:

CallByName(object As Object, procname As String, calltype As Integer, [args() As Variant])

This is a bit limited as it cannot handle return values. I’d also prefer a more object-oriented syntax. So our REALbasic definitions are:

Object.CallByName(name As String, nameType As CallType, ParamArray args As Variant)
Object.CallByName(name As String, nameType As CallType, ParamArray args As Variant) As Variant

In order for this to be usable on any object, we’ll implement these as extension methods. First we need to create a module to contain our methods. Create a module called CallByNameExtension. This self-contained module will eventually have everything we need to use CallByName in our projects.

Next, we need to create the CallType enumeration. This is used to specify the type of the we want to call. Our options are Method, PropertyGet and PropertySet. On our module, create a CallType enumeration with those three values (Method, PropertyGet, PropertySet).

Now create our two method signatures for CallByName:

Sub CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant)
End Sub

Function CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant) As Variant
End Function

Since both of these methods will actually use very similar code, we will create a private worker method to actually do the call. Create a new private method:

Private Function CallByNameWorker(obj As Object, name As String, nameType As CallType, args() As Variant) As Variant
End Function

Note that we’ve changed the ParamArray to just a simple array. This is because we cannot resend the parameters as a ParamArray.

Let’s add the simple code to the public methods:

Sub CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant)
 
   Call CallByNameWorker(obj, name, nameType, args)
 
End Sub

Function CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant) As Variant
 
  Return CallByNameWorker(obj, name, nameType, args)
 
End Function

As you can see, this code simply calls the worker, saving the return value if appropriate. Since ParamArrays are converted to real arrays, we can just pass that along to the worker as well.

In the worker method we’ll use Introspection to actually call the method or to get/set the value of the property. Here is the code:

Private Function CallByNameWorker(obj As Object, name As String, nameType As CallType, args() As Variant) As Variant
  If obj <> Nil Then
 
    Dim info As Introspection.TypeInfo
    info = Introspection.GetType(obj)
 
    Select Case nameType
    Case CallType.Method
      // Get the names of all the methods on the object
      Dim methods() As Introspection.MethodInfo
      methods = info.GetMethods
 
      // Search for the specified method
      For Each m As Introspection.MethodInfo In methods
        If m.Name = name Then
          // We found it, so call it
          Dim rv As Variant
          rv = m.Invoke(obj, args)
 
          Return rv
        End If
      Next
 
    Case CallType.PropertyGet
      // Get the names of all the properties on the object
      Dim props() as Introspection.PropertyInfo
      props = info.GetProperties
 
      // Search for the specified property
      For Each p As Introspection.PropertyInfo In props
        If p.Name = name Then
          // We found it, so return its value
          Dim value As Variant
          value = p.Value(obj)
 
          Return value
        End If
      Next
 
    Case CallType.PropertySet
      // Get the names of all the properties on the object
      Dim props() as Introspection.PropertyInfo
      props = info.GetProperties
 
      // Search for the specified property
      For Each p As Introspection.PropertyInfo In props
        If p.Name = name Then
          // We found it so set its value to the first argument
          p.Value(obj) = args(0)
        End If
      Next
    End Select
 
  End If
 
Exception e As RuntimeException
  Dim eInfo As Introspection.TypeInfo
  eInfo = Introspection.GetType(e)
 
  Dim eMessage As String
  eMessage = "A " + eInfo.FullName + " occurred."
  If e.Message <> "" Then
    eMessage = eMessage + EndOfLine + "Message: " + e.Message
  End If
 
  MsgBox(eMessage)
End Function

This code has one significant limitation when it comes to calling methods: it cannot handle overloaded methods. If you have multiple methods with the same name, but with different parameters, then this code will not always call the method you expect. In order to fix this we would have to compare the types of each of the supplied arguments with the types of the arguments for each matching method and then call the one where everything matches. This is all possible using Introspection, but I’ll leave it as an exercise for the reader.

Download the project with all the code: CallByName.rbp.zip