What is "Open Language"?

[Mark Waddingham]

On 2015-10-26 18:06, Richard Gaskin wrote:
> The gap between understanding low-level data types, structures,
> frameworks, and APIs and being able to write in the lower-level
> language they were designed for is smaller than the gap between
> knowing only xTalk and having to learn to think in terms of low-level
> data types, structure, frameworks, and APIs.

I honestly don't think that is actually true anymore (but what would I 
know, I've only been working with them, and with LiveCode for over a 
decade ;)). OS APIs are much higher level than they used to be - indeed, 
the number of 'type' concepts you tend to need to use them has 
diminished greatly - mainly because OS vendors now see the need that 
they need to be 'mappable' from any language. Indeed, once someone has 
written the 'bindings' which describe how the OS APIs can be leveraged 
from another language - anyone who comes along subsequently doesn't even 
need to concern themselves with how they were originally defined.

These 'type concepts' actually do very easily map in an xTalk-like way 
as long as you are willing to drop the 'stringyness' (this is mainly 
because many OS APIs return what you could call 'transient objects' 
which need to be manipulated - you can't think in the traditional xTalk 
'stringy' way to work with these in a simple way).

One of the principal differences between LiveCode Script and LiveCode 
Builder is that LiveCode Script tries very hard to be a 'typeless' 
language (okay so it has arrays so it isn't really), whereas LiveCode 
Builder doesn't - it has dynamically typed semantics which are strictly 
enforced.

Now, the amusing thing is that LiveCode Script has never hidden you from 
typing (nor has HyperTalk, or any of the others) - you still have to 
think at times... Hmmm - is this a number, is this a string, is this 
'true' or 'false', is this an array (after all you can't add 1 to a 
variable which contains "foo").

Indeed, there is a huge subtlety in terms of typing which actually 
defines the current difference - LiveCode Script will try its best to 
match an input argument's value (type-wise) to the context it is being 
used in (this is essentially 'typelessness' save for the fact that 
MetaTalk ceased to be typeless when arrays were added). LiveCode 
Builder, on the other hand, will require you to tell it that you want to 
convert an input argument's value to (if they don't explicitly match).

> Indeed, that's the point of xTalk.

Is it? I suspect you have your own ideas about what 'the point of an 
xTalk' is (which doesn't appear to include syntax, based on many of your 
comments recently and over the years), and a lot of other people in the 
community will have their own ideas.

The point is that there are many many facets which make LiveCode 
(Script) what it is and all of these need to be preserved as most people 
will depend on a subset of them (I'm not talking about features here - 
I'm talking about the ideas that underpin the language).

Here's a first stab at a list (again, I'm not even talking about the 
actual objects you can create, or the functionality you can access, nor 
the IDE):
     - English-like syntax which minimizes symbols and attempts to 
maximize readability
     - Contextual typing (a polite way to say almost typeless but 
'polluted' with arrays ;))
     - Automatic mutability ('put x after tString', automatically makes 
tString something which can be appended to)
     - The ability to manipulate parts of an object easily, in both 
evaluation and assignment contexts (chunk expressions)
     - Named hierarchical objects manipulatable at runtime (create field 
/ delete field etc.)
     - The ability to attach scripts to objects which automatically 
connect signals (on mouseUp actually directly specified at the target 
level)
     - Gated dynamism (do, value - explicit access to runtime compilation 
and execution under well defined terms)

Then, of course, if you step back from the language you get to also 
consider:
     - Edit / Run live (no stop-the-world compile cycle)
     - Integrated editing environment
     - Domain specific language for manipulating UIs
     - Cross-platform

Overall there is something about LiveCode Script (and the xTalks which 
have gone before) which does seem to make writing code easier (if there 
wasn't, I wouldn't be here) - however, quantifying that into actually 
fundamental aspects of it is not an easy task.

Warmest Regards,

Mark.

-- 
Mark Waddingham ~ mark at livecode.com ~ http://www.livecode.com/
LiveCode: Everyone can create apps