Advantages of LC as high level language--examples

Jeff Massung massung at
Mon Nov 29 19:40:46 EST 2010

On Mon, Nov 29, 2010 at 1:29 PM, Devin Asay <devin_asay at> wrote:

> Hello all,
> In trying to explain to students how high level languages such as LiveCode
> can make development faster, I would like to give concrete examples of how
> single-line LC commands actually execute dozens of C++ commands in the
> engine. For example, a simple one-liner like:
>        show field "demo" with visual effect dissolve
> Must have lots of lines of compiled C code behind it.

Sorry to be blunt, but Lines of Code is one of the most horrible metrics for
defining how productive someone can be in a language. By that rational APL
is one of the most productive languages of all time, and I dare anyone here
to actually use it. For example, here's the Sieve of Eratosthenes (finding
all prime numbers up to X) in APL:


That's worth at least 8-10 lines of code in LiveCode Script, but I can't
imagine anyone here would consider APL a more productive language.

Similarly, the example of the dissolve is equally poor. Keep in mind that
LiveCode doesn't give you the dissolve for free. There are many lines of
(probably C) code that implement that for you and call into QuickTime or
other libraries. And with LiveCode you only get one dissolve. If you'd like
it different, tough. So saying it's "one line of code" is a cop-out, and by
that rational, a C programmer could just download a rendering library that
does the same thing and do:


And now they are just as productive as they would be (given that example) in
LiveCode. The same will be true of Jim's comments on
architectures/platforms, and Jacqueline's example of creating an alias.

So, now that's out of the way, let's examine why LiveCode *is* more
productive for many tasks than C or similarly derived languages... LiveCode
is exactly what it claims to be: Live. Being high-level is simply
[delicious] gravy.

Time-to-market is a major factor in ROI and being able to start taking the
second step in whatever your plan(s) may be. In my experience, the single
biggest factor in reducing TTM is being able to iterate on ideas extremely
fast without concern for what's necessarily "best" at the moment. After all,
90% of all code written will never see the end of the product. But what will
is the knowledge gained from trying it out and slowly making things better
and better.

What LiveCode allows someone to do is continually iterate and improve their
code in a living environment complete with data that doesn't go away every
time there's a bug that needs to be fixed. This puts LiveCode apps in the
interesting position of being constantly dog-fooded (, and this will only
make the applications even better. During that period of discovery and
"knowledge gaining," there's no feeling of starting over, but rather just
continually improving what's already there.

I could go on, but I think I'm getting the point across.

Jeff M.

More information about the use-livecode mailing list