REALbasic vs. Revolution

[Ken Ray]

Lorin,

I haven't said much in this "debate" because usually it's a matter of
personal preference. Many people find VB very easy to use; others find it
foreign or difficult. Some find Rev easy, others find it not so easy. There
are so many factors involved (amount of programming background, tools used
in the past, frustrations encountered, "cool" things that other programs had
that you hope are in this one, etc.) that it is tough to make a clear
statement one way or the other, and it is the purpose of the company that
makes the development environments to make it clear as to what it feels are
the good points (and more importantly the challenging ones) in their tool.

As someone who's used VB for 7 years, and xTalks for 10, I can tell you that
for me it generally boils down to three basic points:

1) How easy is it to understand the basics (sorry for the pun) of the
environment?

2) How quickly do I adapt to the environment so that it doesn't feel "wierd"
to me?

3) Does the environment have the necessary "chops" (functionally) to create
the kind of programs that I need to make?

For me, interface is a key... not *adherence* to a specific OS's interface,
but within its own context. I am from the school of "try and keep to the
OS's interface, unless it makes better sense to do something else"... ;-)

> More English like than COBOL or Pascal, certainly. That said readability
can
> significantly and negatively impact write-ability, at least in my
> experience. I have to say, I'm one of those people who has a really hard
> time with xTalk type languages (including AppleScript) but not with
> REALbasic (my first success in learning programming after YEARS of trying
> all the others).

I agree with this, for the most part. However there's also the comparison
between how long it takes to initially write it, and how long it takes to
modify it after you have not seen the code for a year. In general, I'd
rather write more up front so I don't have to reinterpret my code a year
later. However there are some variations that (to me at least) are just as
readable a year later:

  tVar = 100

is just as readable as:

  put 100 into tVar

to me.

And as far as AppleScript is concerned, it has it's own rigorous syntax to
adhere to and you can't debug the thing anyway... ;-)

> This is a religious issue. It's interesting to compare PHP and REALbasic
> (the only two languages I have passing familiarity with) in this regard.
In
> PHP variables are weakly typed but operators cannot be overloaded. In
other
> words you can use the "+" operator with a string "123" and double "2.34"
and
> like so (note not real PHP):
> myresult = "123" + "2.34"
>
> print myresult
>
> and get: "125.34"

Rev does the same thing as PHP here:

  put "123" + "2.34"

gives you "125.34"

> In REALbasic, you might have the same two things:
> dim myString as String
> dim myDouble as Double
> dim myResult as Double
> dim myOtherResult as String
>
> myString = "123"
> myDouble = 2.34
>
> myResult = val(myString) + myDouble
>
> In this case, myResult = 125.34
>
> If you want to display that, you would convert it to a string:
>
> myOtherResult = str(myResult)
>
> Here's where it becomes more interesting.
>
> There's no concatenation operator in REALbasic (I think it's "&" in
> AppleScript).

And in Rev as well, so to get "1223.34" you do:

  put "123" & "2.34"

> So, if what you actually want is "1232.34" you do this:
> myOtherResult = myString + str(myDouble)
>
> This is sort of a wacky example, but overloading is something that makes
> Object Oriented Programming powerful.

And Object-Based as well... ;-)

Just my $0.02,

Ken Ray
Sons of Thunder Software
Email: kray at sonsothunder.com
Web Site: http://www.sonsothunder.com/