Slashdot Mirror

Please, visit http://livecode.com/download/ and download the most recent version of LiveCode Community Edition (Open Source) for your OS: (Linux, MacOS X, Windows) If you visit this webpage: http://downloads.livecode.com/... you will find all downloads available, including stable public releases, release candidates and developer previews. Choose one of the stable releases and install it in your computer. Then, you will understand why many developers still cherish and remember fondly, it's first encounter with HyperCard. You could download Livecode's source code from Git: https://github.com/runrev/live... Learn about Livecode's quality controls at: http://quality.runrev.com/ By the way, HyperCard found it's way to many platforms in the form of clones: For Commodore Amiga, there was UltraCard (later renamed Foundation): http://www.dreamtimestudioz.co... For Linux, there was MetaCard (today Open Source LiveCode): http://www.metacard.com/ For Windows, Oracle Media Objects: http://en.wikipedia.org/wiki/O...

http://www.xojo.com/
http://runrev.com/

I think the motivation is primarily uptake but there's going to be some interesting side effects. For example there are a number of people very keen to see this on the Raspberry Pi which will require an arm Linux engine as currently we only have x86. As the core goal of the Raspberry Pi is programming education I think LiveCode will fit nicely between Scratch and Python. The language is very much like the scratch language without having to drag blocks around.

I am starting to wonder if pitching the kickstarter as being for open source was a mistake. People are wondering why that costs anything. It would have possibly been better to just say... we're going open source but we want funding to make some massive changes to the platform. Here's an example of one of the core goals of the project http://blog.runrev.com/blog/bid/265511/Open-Language which I think is huge. Besides being able to extend the language with DSLs for your data model or library which is big on it's own there's two other VERY interesting possibilities:
  - create functionally equivalent syntax in another natural language (e.g. French like syntax rather than english) and the engine could display whichever syntax the reader preferred.
  - add other existing scripting languages (e.g. javascript or python) therefore giving them a cross platform UI framework

It looks to me like they'll be dual licensing. GPL3 is mentioned on the Kickstarter page, which presumably includes the deployed runtime libraries, so anything built with this version must also be FOSS. Anyone who wants to build a proprietary application will have to buy the commercial version. This is probably a good move for them. Although LiveCode pitched as an easy to use RAD, the current pricing is too high for casual developers:

http://www.runrev.com/store/

A GPL edition will kill their education sales, but they should benefit from a much bigger user base and more potential future customers for the commercial version.

Livecode is cross platform - Mac/Win/Linux/IOS/Android (and others) with one codebase and development tool on Win/Mac/Linux.

I've been using it for a couple of months and it's great.

And the language is more like English than code!

http://runrev.com/

Full Disclosure - I Don't work for them.

Any cancelled project that was *truly* useful has several open-source versions of the same idea. So, where is hypercard for linux?

LiveCode

Exactly. If I had mod points, I'd mod you up.

Apple's somewhat painted themseves into a corner on this. That is, they decided that they wanted to give users the ability to run native apps, but (unlike Palm or WinCE at the time) with a consistent, predictable app experience (no crashing, memory leaks, terrible UIs, porn, writing/reading all over the filesystem, spamming users, etc.). That means that they need to review all apps to filter out the crap. But then that means that all software has to go through that process, so you have to prohibit the ability to bypass the app store approval process. Which means that you can't let people program directly on iPhones/iPads, or to distribute software through downloads that bypass the app store approval process.

The only way out of this is to use the web browser, which can download and run software, but the user is protected because it's all JavaScript running inside the browser's "sand box", limiting the damage that badly behaved software can do.

There are some descendants of HyperCard for Mac OS X (and Windows), such as http://runrev.com/. Functionally they're amazing. But they aren't positioned as tools for novices because they have to convince people to find and buy them (or at least download them, for the free ones). And while HyperCard was great because it was easy, it was also important that it was automatically provided to everyone for free, so novice users could easily find and use it, and even the barrier of having to find and buy a fairly cheap dev tool is enough to scare off novices. For example, runrev's LiveCode is great, but it's between $99 and $1,500 depending on what platforms you want to deploy on. The beauty of HyperCard was that it was easy to use, which includes not having to find or pay for it.

The only way for HyperCard to succeed in its goal of enabling non-technical people to build apps is as a free part of the OS - once it became a paid add-on, it was doomed, because novices would never know about it, much less be willing to pay for it. And professional developers donj't want novice-friendly tools, they want power tools like IB.

Maybe Apple won't bring it back, but others have taken a shot at making similar products. For a while I used a tool called "Runtime Revolution" which as I understand it is very similar to what Hypercard was. Even has the same terminology like "cards" and "stacks". It was also cross platform for Win / Mac / Linux.

It looks like the company has transformed this product into something called LiveCode now.

The somewhat tricky part about programming with it is the thing is basically always running, no compile step involved, although there were buttons to halt message passing so it could basically be paused for when UI work required to UI to stop doing stuff.

Runtime Revolution

Please read the article linked from the summary. Really. They proposed to Apple to rewrite their development so that it would no longer be able to create cross-platform apps, so that all iPhone OS API's would be directly exposed, etc. It didn't matter.

"The claim is "10x more productive""

Yes that is ALSO a claim. And it is ALSO a lie. Although not as easy to refute by simply demonstrating more concise code in just about any other language.

From the runrev.com website:

"Rev is easy to learn and use, requires 90% less code, and can deliver a 10-fold increase in productivity over traditional languages."

http://www.runrev.com/company/about-us/

All said it is probably a fine language for some. Its creator just has a lot of bad karma by marketing it with lies.

Look at the tutorials; for example the File I/O code. I concede that to the average person without any programming education, this may look simpler than its C++ or Python counterpart, but is this syntax really simpler? I think not! On contrary this bit would be easier to code, with a rather lower risk of time-consuming compile errors, in many traditional languages.

I've seen enough attempts to "dumb down" computer languages for people whose computer programming examination only asked: "Which of the following three is not a valid BASIC keyword: (a) PRINT (b) GOTO (c) TERMINATE?" (I kid you not -- when I was at university, this was the level of knowledge expected from bachelor's students in, if I remember correctly, veterinary medicine.) Generally these languages did not succeed in making computer programming easier; they only succeeded in making it look superficially easier. The threshold appears lower for the uninitiated, but after the first three days there is no advantage and you're stuck with a stupid syntax.

The real choice, as far as I can tell, is between a "minimalist" design of a language which provides only those features that a developer is expected to really need, and a "maximalist" design that provides the extra features a programmer might like to have to save him some time and make code look more elegant. The pair Java and C#, despite their similarities in syntax, exemplify the contrasting approaches very well. Personally, having seen how even professional programmers can mess up their exception handling and mismanage their dependencies, I am firmly minimalist. Never mind time saved in writing code, that barely matters. What matters is time saved in code reviewing and debugging, and that is nearly always easier in a minimalist language.

That said, I hope there would be a market for a good, simple language suitable for automation purposes: Something that is suitable for anything from writing macros in a text editor to controlling a complicated robot, for which people now usually reinvent the wheel -- generally producing something roughly triangular with an off-set axle.

You could try learning with revTalk. Its a very high level, English-like language thats easy to learn, read and write. Instead of focusing on esoteric syntax, you can focus on what you're trying to do. Its perfect for beginners because they get to see results very quickly. Yet its powerful enough that you can learn proper principals of software engineering when you're ready. There is a free version available for all platforms http://revmedia.runrev.com/

How about this:

if "foo" = myBar then
answer myBar
end if

Revolution

Runtime Revolution lets people code in plain English... http://www.runrev.com/

Revolution would be ideal for the following reasons:

1. You can download a 30-day demo for Mac, Windows and various flavours of *nix.

2. It supports the basic programming concepts you mentioned without being overly burdened by misplaced semi-colons, strongly typed data, or really.hard.to.read.crappy.dot.syntax

3. It has a GUI with drag-and-drop GUI interface elements that appear platform-native on the platform on which it is being used (and later deployed -- it's truly write once, run anywhere).

4. It uses a scripting language that is like Hypertalk on steroids and thus leverages the students' naturally occurring understanding of natural English language constructs (e.g., "put 3 into myVariable" etc.).

Because it's graphical, because you can test without compiling, because you can start something out in class on, say, a Windows or *nix box, then take your project home and continue working on it on, say, a Mac, and then back again, because it leverages natural language, it really is an ideal introductory programming environment.

Give it a try!

This is a... confusing response.

Question one, did you consider Runtime Revolution at any point in your analysis/development?

It's an open source project. I don't think requiring a proprietary dev environment to modify the code is even *legal* for distributing OSS.

Runtime Revolution looks like a non-free development environment with its own custom dev language -- even if it were free, how could this possibly help the problem of a too-small developer community with the Squeak version?

Does everyone on your team understand the implications of Sun's move from Java 5 to Java 7?

A link here might help. What implications? I'm a Java developer, and I read a decent amount on Java's evolution and haven't seen anything frightening.

There may be much more than sore grapes motivating the disappointment you are hearing expressed from the original team. You're literally trying to move the earth underneath your project. Business manager's instinctive reach for the mainstream or for the "cool" (whichever it might have been) is not a good technical reason for inducing an earthquake in the code base. They have to have more than that, or all the "acceptance" available in business circles really is not good enough reason for this kind of decision. When you let marketing determine the technical directions[...]

I'd agree that it's a big decision to rewrite a project in a new language -- it usually takes significantly more effort than expected, so that's a very valid thing to discuss. But the language chosen for an open source project is very important in building a developer community -- it's not for marketing reasons, it's simple math; when developers with an "itch" want to add a feature, if they don't know the development technology they won't be able to participate.

Or maybe a little driving from the sidewalk, if you'll pardon me for taking the metaphor a little too far.

Question one, did you consider Runtime Revolution at any point in your analysis/development? What were the specific reasons for rejecting it?

I am not employed by runrev, I'm not even much of a fan, just a sometimes user. There may be valid reasons for rejecting Runtime Revolution, depending on what you are trying to do. But I strongly urge you and the entire team to be sure you understand what those reasons are, because you are going to be re-inventing a lot of wheels in many more ways than one.

Question two, has technical management clearly understood the issues underlying dynamic objects? Can they write competent, real-time time-line based multi-module code in each of Java, Smalltalk/Squeak, and Objective C? (And Runtime Revolution's implementation of Hypertalk, to be thorough.) Do they know what they (not just the Bulgarian team) are going to fight with when they shift from Squeak's object model to Java's object model? (Delayed reference resolution is not a trivial topic.)

Does everyone on your team understand the implications of Sun's move from Java 5 to Java 7?

There may be much more than sore grapes motivating the disappointment you are hearing expressed from the original team. You're literally trying to move the earth underneath your project. Business manager's instinctive reach for the mainstream or for the "cool" (whichever it might have been) is not a good technical reason for inducing an earthquake in the code base. They have to have more than that, or all the "acceptance" available in business circles really is not good enough reason for this kind of decision. When you let marketing determine the technical directions, you're doing the exact thing that most typically kills projects, and it is exactly what a lot of funding at an inappropriate time tends to do. (I've seen this personally. Watched a decent company bury itself in inappropriate funding.)

Trying to think of examples where this kind of thing succeeded, I can't. When Apple moved from Pascal to C, they were able to keep most of the underlying run-time and most of the documentation. The headers (the machine-readable part of the API) were a mostly mechanical translation from Pascal syntax to C, and that succeeds because Pascal and C are syntactically close. (Closer than C is to Java, really.) That was nothing near the kind of shift going from Smalltalk to Java.

Nevertheless, as you are probably aware, the original Macintosh code base has now been officially abandoned, as has the classic Macintosh UI and API. Apple succeeded with that precisely because they were not just kicking the version numbers up. They maintained compatibility through emulation (expensive, but cheaper than actually trying to maintain it in the API going forward) and they have now jettisoned the emulation. The only connection that remains is some of the user base and some of the engineers, and the name of the Company. You cannot take even a simple application written for Macintosh System 7 and run it on Mac OS 10.5 either under emulation or even by a quick re-compile.

I could go on, but I know I'm not even a passenger in the same car, so I'm kibitzing from way out of context. But I don't think I should just agree with the chorus of, "Forking is part of the reason for open source!" It is true that forking is part of the reason for open source, and, much though you may not want to see it that way, what you are attempting is most definitely a fork by any engineering definition. But forks are a bit beside the point.

If you are satisfied that you have checked all these issues, my comments are unnecessary. I offer them in case you haven't.

You know, Mellon could have funded a Revolution and saved a lot of money.

I think I would assume, however, that they actually considered runrev and had reasons for wanting to depart from the Hypercard legacy.

Why head from Hypercard to Java, I'm not sure. Is Java 7 better at dynamic stuff than Java 5? Or have they discovered that attempts to generalize dynamic linking generally incur huge penalties in both speed and stability?

There's a reason Mac OS X is not written in either Java or Squeak (Smalltalk), you know.

Though I find it an innovative way to revive your old stack and share it on the web, I can't help but wonder about security, privacy and copyright. Meanwhile, Runtime Revolution have just announced their revamped web strategy, and demoed a Flash-like browser plugin - which means you don't have to install any special software on your server. Just create your stack on MacOSX, Windows or Linux and then deploy it for the web. For a short introduction of this plugin-to-come: http://runrev.com/newsletter/may/issue48/newsletter1.php - I was there during the announcement and got some time to play with it, and it is indeed a great way to share your stacks over the web.

Here's its ancestor - quite nice really. http://www.runrev.com/

There's also Runtime Revolution which is cross plataform, has access to sql databases, advanced networking and imports hypercard stacks. The Revolution Media version is way cheaper that $179. You can develop your stacks and run them in Macs, Linux and Windows. For all those that loved HyperCard, I think that Runtime Revolution is what they've been waiting. The web site is http://www.runrev.com/

I'm not sure you're well informed on this. Revolution -- http://www.runrev.com/ -- does everything HyperCard did and more, is cross-platform for Mac, Windows, and Linux, and starts at $49 for Revolution Media.

Although Apple abandoned HC a long time ago, it still lives on, today in a product called Revolution. Revolution is definitely a child or grandchild of HC. If you build applications in HC, you should have no trouble running with Rev. There's even a section on their website discussing that topic. It is definitely far from perfect, but it's better than FORTRAN.

I highly doubt Apple will revive HyperCard. However, a very good alternative exists. It's called Revolution and it's cross-platform for Windows 98/Me/XP/Vista, Mac Classic and OS X, various flavors of Linux and Unix, and can even be used as a CGI on web servers. Of course it's full color, supports the latest visual effects, has object-oriented/vector graphics, and has corrected virtually all of the limitations of the old HyperCard. (For example, it's compiled, not interpreted -- without sacrificing the ease-of-development HyperCard had -- so it runs very fast.)

It has full libraries for XML and various Internet/Sockets operations, an integrated database engine (SQLite) and native support for MySQL (no ODBC drivers needed) and a number of other databases. It's a great front-end for DB systems (especially when you consider there's no per-set cost, because you can create royalty-free standalone executables on any of the supported platforms).

You'll find more info on it at http://www.runrev.com/

If you want to program in HyperCard's beautiful natural language, Revolution is really the best way to go. There are other clones out there but they are either woefully unfinished (PythonCard), support only Mac (SuperCard), or are designed for kids.

I thought Supercard became Metacard which renamed itself to Runtime Revolution? Actually, Metacard was pretty neat, they even had Linux/FreeBSD/Windows stacks, although it never had quite the same level of support from the OS that Hypercard had back in the System 7 days when I used it (I remember pulling up ResEdit and dropping sounds/pictures/etc... in my stacks, not to mention the compiled add ons). Metacard had compiled add ons as well, but they were something of a pain to get working.

Sorry. Cygwin DOES NOT work AT ALL! Why? Because of microsoft Virtualized File System and some security restrictions (ie. you can write a file from Windows but not use any cygwin tools to modify it!). You see, the geniuses at MS thought that it is better to be a PITA to current developers than get people to select some Compatibility mode for old apps to enable Virtualization explicitly.

What is Virtualization? Well, see,

http://msdn2.microsoft.com/en-us/library/aa965884. aspx
http://www.runrev.com/newsletter/march/issue21/new sletter3.php
http://support.microsoft.com/kb/927387

Essentially, a normal 32-bit EXE without an embedded manifest (a manifest that can crash XP!) will be treated as legacy and any write operation to LOCAL_MACHINE/Software or the file system outside /Users will be "Virtualized". That is, the write open will succeed but will be silently redirected to some subdirectory in /Users or CURRENT_USER registry key. You can image how stupid this is by default.

Embedding a manifest is a freaking pain the in the ass. MS Visual Studio doesn't even do it properly by default. At least its embedded manifest does not work (disable the freaking virtualization in Vista). And as a consequence, things like Cygwin are now hopelessly useless because file access outside /Users is disabled (writing) even when the user has permissions to write and modify said files.

Have you looked at AppleTalk Studio? Reminiscent of HC.

Of course there's always http://www.runrev.com/

here are 3 more you should look at:

  http://www.alice.org/
  http://www.opencroquet.org/
  http://www.runrev.com/

  The first 2 are free, the 3rd is commercial - sometimes
      free versions show up on the DVDs from british computer
      mags.
  I looked at several 3D programming enviroments a few
    years ago, and these stood out as being accessible
    to beginning programmers. I can't give much detail
    beyond that, all three have pretty good documentation
    and active communities. They are also notable for making
    fairly complex graphics easily accessible.
  That isn't much to go on, but it will be very worth your
    while to look at these environments.

IIRC, there were a number of IDEs that mimicked or emulated HyperCard's model of programming, most notably Revolution and SuperCard, but the sticker price and the extra complexity built into them for writing "modern" software kept them out of Joe Average's reach. I would definitely support any project that wanted to put programming back into the hands of the "masses." I believe that programming is an essential skill to learn and a great way to teach people that computers are not mystery boxes that break if you push the wrong button, but tools you can use to design tools to get jobs done. And something like HyperCard or Visual Basic, designed for the "average user" in mind, might be just the thing.

Hypercards' decendants have come a LONG LONG way since those days... check out: http://www.runrev.com/ and download the demo support list archives can be found at: http://mail.runrev.com/pipermail/use-revolution/

Hypercards' decendants have come a LONG LONG way since those days... check out: http://www.runrev.com/ and download the demo support list archives can be found at: http://mail.runrev.com/pipermail/use-revolution/

I've used Runtime Revolutions' DreamCard for the PC and it's Mac OS X version seems just as competent. It's a holdover from the HyperCard days apparently, but the IDE is OK. The scripting language seems Basic like but the syntax can be a little odd. Might be worth looking at though.

If Basic is not to much the turn off, then perhaps RealBasic might be worth a look. The IDE and language remind me of a combination of the VS6 and PowerBasic products combined for OS X.

Again, most /.'ers will probably sneer at these tools since they aren't C and possibly aren't enterprise level solutions. But for a quick tactical level program, they might make for a good solution.

Probably worth less then $0.02, but I thought I'd add some RAD into the conversation.

Mac OS has a five-button mouse, it's just that four of the buttons are on the keyboard.

Even the most extreme X11 user with a MIT double-bucky keyboard wouldn't have thought of command-option-control-click (also here and here) or command-option-shift-click (also here)...

Having a contextual menu button from the beginning would have discouraged developers from adding a bunch of chord-combination clicks to make up for the lack...

http://www.metacard.com/
(although sold to runrev for commercial development, getting the old metacard IDE and heading over to yahoo groups, you will find some nice geeks continuing development of the free version)

http://www.hyperstudio.com/
It's been forever since they released a new version, and there is no Linux version of the software.

http://www.squeak.org/

I'd recommend SuperCard. When Apple abandoned HyperCard, they left a big void. SuperCard is OS X native and has excellent HC compatibility. Of course, it's far from a HC clone, as it it has all the things you'd expect from a development environment these days.

SC allows you to build standalone applications playing movies with QuickTime, displaying graphics with alpha channels, running shell commands and AppleScripts, etc...

I also personally use Runtime Revolution, and it's also good, and cross-platform. However, for Mac-only development, SuperCard definitely has my vote. It uses true Aqua GUI controls, and behaves like you expect Mac apps to do.

Here's a few Mac apps I develop with SuperCard: http://www.lightheadsw.com/

It was said:

Pretty much the only competition is Macromedia Director and Runtime Revolution... both of those produce alien-looking not-quite-native interfaces. (Although at least Director is good for game development.)

Director does indeed "produce alien-looking not-quite-native interfaces" (not native at all, in fact), but the UI widgets created in Revolution apps look like their native WinXP, Win95/98/2000, Mac OS Classic, Mac OS X, and I think KDE Linux counterparts when deployed on those platforms. Take a look: http://www.runrev.com/

You are perhaps incorrectly recalling the amateurish UI deployed by Revolution's predecessor, MetaCard?

Yes, this is way late, but I hope you are tracking this via your personal comments page...

Off the top of my head are SuperCard and Runtime Revolution. Also, if you only care about the Mac, AppleScript Studio, while not as elegant as the above, uses a programming language decended from HyperTalk, and it's a free part of Xcode.

Two words for you. runtime revolution

particularly the GUI-drawing system

From my experience, this is the most commonly sited perk of VB. It's something that you've been able to do for darn near any language for a long time- GUI designers really aren't new, and VB doesn't even have the best one available.

The frequency that I see people cite the GUI designer as the major benefit to VB makes me think that most folks- especially the types of people on /.- seem to be stuck in the past, coding all of their GUIs manually. I know that the development setup is generally some years behind for most Linux developers compared to your average coder on Windows or Mac OS X, and that there are fewer good and polished tools on Linux. But still- there are free GUI designers for GTK+, FLTK, Qt and Motif. And for just about any other toolkit and language. Do people not use these?

That said, tools like VB and RealBasic (with which I've more experience than VB) are RADs for more than just a GUI designer. Using Glade for a C/GTK+ app won't make you as productive as a seasoned VB coder for simple app development, but it will shave off some time spent coding the GUI programatically.

But there are options, and some darn good ones on, for Linux:

Prima: a new GUI toolkit for perl- including a really nice RAD GUI builder- for Linux, OS/2 and Windows.

Squeak Smalltalk: Runs on just about every platform. Uses a seperate GUI toolkit, but affords a huge amount of power and ease of development.

RealBasic: A cross-platform VB clone for Mac OS Classic/X, Windows and Linux. *Really* nice. Costs money, but it's worth it.

RunTime Revolution: Has a HyperTalk-like language and runs almost anywhere. ...and others. But those are some that embody the feeling of a RAD IDE like VB. That is, they do more than just add a GUI designer.

Revolution has a free trial version that can do just about anything the full one can if you don't mind using a couple of tricks and the support community is excellent. Revolution is basically hypercard with a bunch of new features and is constantly being updated.

It still exists and I would highly recommend it as well. anyone can turn out quick and dirty applications that do real work, without having to really understand anything other than ordering instructions. Metacard andRuntime Revolution being the best current examples. Rev is my favorite for doing alpha testa.

I recommend Revolution. It's similar to HyperCard and uses a very english-like programming language called Transcript. Works on Windows, Mac OS 9/X, Linux, BSD, etc... :D

http://www.runrev.com/

Have you tried Realbasic? It seems to be powerful enough for people to use for "real" programming (and it's crossplatform, well, at least it runs on Macs and PCs.) You can also try introducing her to a stack-oriented scripting language (similar to Hypercard.) There's one called Runtime Revolution and it runs on Macs, PCs, and Linux (according to their website.)

I'd personally find stack-oriented scripting languages easier to pick up (from a newbie's perspective) because the process of dealing with event-driven loops is automatically built into the environment - you just have to tell the stack how to interpret button presses, etc. Also, it's easy to keep things segmented - individual scripts live on their own cards, and you can link the cards together in any particular order you want.

I tried learning Eiffel.
Really liked the concept, its not that hard.
And definitely much prettier/neater than the grotesque C# (which am not proud to admit is the language I program in most)
Eiffel code is heavily based on structured English, ok it won't go as far as Revolution whose syntax is 100% English.
Eiffel code is very object-orientated but not as bizarre as Smalltalk which vows to be easy but most people finds it the opposite.

Eiffel seems to produce very safe code, because of contracts .. so, of what I understood, you are force to debug/test each time you write a new class and function. If your project finishes - your app should be incredibly stable - so no more BugBuddies or CrashHandlers :)

Eiffel's code seems like documentation, because of the tags.

Real shame I couldn't play with it more - but seriously, it's just a hunch, Eiffel is a very powerful language. And for many things it can make a difference ... Java, C# and C++ (specially) just begs for crashing apps.

1. Runtime Revolution
2. SuperCard
3. PythonCard

There may be others...

Try Revolution. It's like Macromedia Director, but it's available for Linux, Windows, FreeBSD, Mac OS, Mac OS X, AIX, Solaris, SunOS, HP UX and SGI Irix

Runtime Revolution
Compile on any platform, to any platform- including a ton of *nix variants. A very nice cross-platform rapid application development tool with a very complete set of functionality (interface, database, tcp/ip ports, etc.), all coded in a HyperTalk-descended language.

X-Builder
Mostly designed for multimedia, I don't know as much about this one...

I don't use VB. Ever.

But then again, I do use REALbasic for making Mac OS 9, OS X and Windows apps on occasion. And I'm not afraid to admit it!

For those who would like something like VB, but cross platform, Revolution a free-beer RAD tool compiles to Mac OS 9 and X, Winders, Linux, and oodles of other Unices. It's kind of like VB + HyperCard.

Macromedia deserves some credit for staying in tune with the development world. But lets face it: Flash is for art majors. Even with its "standard" controls that are now available (e.g., scrolling text box), it is still a difficult environment to control; you always feel like "this could look so much better with this spinning, pulsing button." All those vector calculations in Flash still bring a PII to its knees. If people are interested in Web applications, they migh consider Runtime Revolution, a cheap ($300) cross-platform (Mac, Win, Linux, etc.) alternative with native support for sockets and other amazing tools, including multimedia support, that really allow you to accomplish what needs to be done. I've spent a LOT of time trying to find the right rapid application developement tools for the job, and Runtime Revolution has yet to be beat. Python with Boa Constructor (v .2) and Mcmillan installers is certainly awesome, but the multimedia (i.e., Quicktime) just isn't there yet. In other words, there are a lot of very nice alternatives to Flash, which is really not much more than a glorified banner advertisement tool.