A Little Revolution Does A Developer Good

Round here we develop all of our desktop applications using Revolution. I recently attended the RunRevLive 08 conference in Las Vegas where one of the speakers was Robert Cailliau, the co-developer of the web. Robert spoke on “Programming systems and the birth of the Web”. Following a very interesting presentation on how the web came about he discussed some characteristics he thought a good programming language should have:

You should not need the reference manual lying open next to you.

A good assignment operator.

The less “swear” characters the better. These are characters from the top of the keyboard and are like the top shelf at a newsstand – dirty.

You should not need lots of comments.

His point was that you spend most of your time reading your code, not writing it. Therefore the language should be easy to read and understand. Since Revolution uses an english-like syntax it fulfills all of Robert’s criteria.

Here are some examples of what Revolution syntax looks like:

set the text of field “Greeting” to “Hello there!”

put the hilite of button “Checkbox” into theButtonIsChecked

At first I thought the syntax was too verbose. But as I have used Revolution more over the years I’ve come to prefer this verbose syntax because of how easy it is to read. Robert is right – I do spend most of my time reading code. So whether or not the code takes a little longer to write isn’t as important as whether or not it is readable. Plus you can drastically reduce the time it takes to write code in Revolution with a script editor such as GLX2 that supports auto completion.

There are some drawbacks to the language though. For instance there is no inheritance and you can’t define your own objects (you can only modify existing ones to suit your needs). Both are features that would make development easier for me. While these missing language features are not a deal killer they do make some types of development more difficult.

Recently Greg and I were discussing our development tools as we looked at where we wanted to take our products in the coming months. Another drawback of Revolution is the small collection of 3rd party libraries to choose from. A large selection of quality 3rd party libraries is a major asset for a development tool since you can integrate mature, tested code into your application. This can save you many hours of development time.

After taking into consideration the various drawbacks we still came to the conclusion that we couldn’t get as much done in another cross-platform desktop development environment as we could with Revolution. Here is why I think that is:

In Revolution you compile object scripts, not applications.

You design in real-time.

Revolution allows for a truely cross-platform code base.

Revolution is a 4GL – no need to manage memory.

The code you write is Readable Code

Compiling Object Scripts, Not Applications

In Revolution each object has a script property. When you set the script property of an object the code is ready to execute from within the Revolution IDE. What this means is that you are writing and running code as you work. This is incredibly powerful since you don’t have to compile your application in order to test. This may be the coolest feature on the planet.

Design in Real-Time

Like other development tools out there Revolution makes it easy to create windows and add buttons, fields, etc. The difference with Revolution is that you can write the scripts and test while you are designing. Everything is happening in near real-time which means there is no wait while you compile to test out your new idea. It is a very fluid experience.

Cross-Platform Code Base

In Revolution you really have a single code base. There are very few surprises (but how your fonts display is one of them) when you go and test your application on Windows after having developed it on Mac for the last week. The really cool part is that I can be working on the application in OS X, save the file I’m working on in the IDE and instantly launch the application for testing on Windows over the local network or in VMWare. This saves you countless hours of compiling and testing on different platforms.

No Need to Manage Memory

I have no idea by what order of magnitude your coding productivity increases when you don’t have to worry about memory management. I bet it is really high though. It is one less thing to think about and it happens to be the thing that causes a fair number of bugs during development.

Readable Code

When all is said and done Revolution is very readable which makes it easier to maintain and improve upon. Even if only one or two people are ever going to see the code it is amazing how fast you can forget what you were thinking when you coded something just a few weeks ago. An easy to read syntax that partially documents itself makes getting back into old code much easier.

So while the Revolution language may not contain some modern features and there may not be as many 3rd party resources, it’s design offers some impressive advantages for those looking to write cross-platform desktop applications. The language will evolve and more 3rd party libraries will be written. What I think is key is that Revolution delivers an environment that is truly built for rapid application development.