Kickstarter 2013 Revisited

[Mark Waddingham]

> I have taken quite some time to write this, and the reason that I have
> taken the trouble is that, oddly enough, I both believe in Runtime
> Revolution, and have put a very significant amount of time and effort
> into learning how to get the thing to do things over the last 14
> years.
> 
> Had I come to it just before the Open Source Kickstarter campaign I
> don't think I would have bothered, and I don't think I would be
> working
> with LiveCode just now.

I appreciate the time you have taken - and, indeed, I appreciate your 
ongoing support (which you clearly still give unconditionally it seems, 
even though you are perhaps not entirely enamoured with the way we go 
about things!).

Indeed, the fact you have taken this time suggests that we (from the 
technical point of view) have failed to a certain degree to communicate 
adequately what we are doing and the path we are taking to achieve it.

I'm not going to go into specific details or responses to your direct 
questions just now as that would take longer than I perhaps have on an 
idle Sunday evening whilst my other half is working - but there is 
obviously a communication issue here we need to address and we will in 
time.

In the meantime, however, please believe me when I say that no 
KickStarter goals have been forgotten - they are just taking longer to 
achieve than we had originally hoped. Indeed, in the process of 
attempting to achieve them we did decide to go down a slightly different 
route than we had originally intended.

The reality is that the scope of what LiveCode is, and indeed we want it 
to be, is so wide that the current rift between engine and script cannot 
continue if we are to keep up with the pace of evolution of the software 
industry. We have an engine written in what I would term C++ish (the 
codebase goes back 25 years or so at this point), and we have an IDE 
written in what we term LiveCode Script (LCS). C++ is not a forgiving 
task-master and in reality if you are using LiveCode you are probably 
doing so to avoid using C++ or other lower-level languages to a certain 
degree.

Therefore, as a result, we are in a situation where the people who 
perhaps would be best to help evolve the platform find it difficult to 
do so having to rely on those who have C++ abilities (and, indeed, 
understand how the engine works!). This disconnect directly reflects the 
more fundamental problem which LiveCode is intended to solve - 'Everyone 
Can Code' is an ambitious goal, certainly, but the way by which it works 
is having a high-level system which is tailored towards individual 
domains (black-boxes tied together with a flexible language for 
composing and expressing algorithms that act on them).

The solution we came up with is widgets. We are trying to raise the 
level at which the majority of what you currently consider to be 'the 
engine' is written so that there isn't that rather large chasm between 
the way the the functionality you use everyday is written and the 
functionality you build atop it. By raising the level of language in 
which 'the engine' is written, we both gain rapidity of development for 
ourselves, but also (perhaps more importantly) raise the ability of the 
LiveCode community as a whole to introspect on and also adapt and 
improve what we do.

Of course, I say 'try' here - but there is no try. It works, it really 
does work. Even in its nascent form LCB is proving to be a highly useful 
and productive way to implement the things people really need and it can 
only get better as we iterate on its feature-set and its gradual 
unification with LiveCode Script.

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