“AS failed at natural language though.”

It didn’t fail. It never was.

AppleScript is a screamingly conventional, traditional, conservative Algol-style language; which just happens to be dressed up with an app-extensible pool of keywords and lots of built-in homonyms and synonyms to make it look non-programmer friendly.

Not a bad idea from a sales POV, as the biggest barrier into end-user automation for end-users is how hard conventional programming makes itself look. But it failed, because it was a fake; a bait-n-switch. The road to Pedagogical Hell is paved with its ilk. Complexity, made to look simple, instead of just being made simple.

Thus AppleScript looks easy and inviting to non-programmers, but it’s every bit as complicated, convoluted, difficult, and utterly intolerant as every other Algol-descended scripting language (Python, Ruby, JavaScript, etc, etc); and worse, the “helpful” syntax goes deliberately obfuscates much of that complexity to pretend in its simple and uniform.

The most egregious instance of this “damned with good intentions” is AppleScript’s attempt to make the conceptual and behavioral mismatch between the language’s own local, procedural world and the remote, query-oriented worlds of “AppleScriptable” applications which is accessed via its embedded Apple event bridge.

Ironically, non-programmers aren’t bothered by this because they don’t understand it well enough to know any better. Whereas skilled professional programmers absolute hate it, because they actively misunderstand it: they know OOP, application scripting looks like OOP, therefore they assume it is OOP. And then, all that expert understanding and confident on how their scripts will work are completely smashed as “AppleScript” proceeds to behave in profoundly NON-OOP ways, utterly confounding those predictions and proving that something is wrong without ever explaining who or why. So in total absence of any better information, programmers conclude that it is AppleScript that is wrong, and file under Hated and Rubbish.

…

All this might not seem relevant to NLP, but if you don’t understand pedagogy and why previous attempts at end-user languages fail, you can you expect to do any better than they did? Throw enough magic AI pixie dust at it, maybe? I suppose it might be possible to brute-force a solution with sufficient barrel-loads; but then what do you do when that system behaves in ways that mismatch the user’s predictions?

Boom! And you’re right back to the problem AppleScript failed to recognize, never mind solve, 30 years earlier.

In fact, if you want to solve this one you need to look back 50 years, to Seymour Papert’s original work on Logo. The man proved you could build a complete, fully functional and trivial-to-learn language with just three parts:

1. This is a Word,

2. This is how you perform a Word, and

3. This is how you add Words of your own.

As I mentioned elsewhere, I was lead-author on the last edition of Apress’s AppleScript book; a 1000-page monster. Many would consider a thousand pages on the subject a great and impressive achievement.

To me, that doorstop was a disaster: a 1000 pages to explain a “simple, friendly, easy-to-learn language for ordinary users”? (Admittedly I only realized it myself around page 500; and every page after that was absolute hell. No wonder it was 10 months overdue when I finally, barely, wrapped it.) Yet even allowing for my awful verbosity, AppleScript’s baseline complexity is so high that even the best attempt to explain it clearly and completely cannot run less than a 100 pages long. A pedagogical instant “Fail”.

Again, Papert proved you can build a language more powerful than AppleScript and explain how to use it on the back of an envelope. To 8-year olds!

And his syntax does not look so dissimilar to yours: just words in a sequence.

…

So, forget NLP. The correct answer you seek is “Pidgin English”. (And feel free to replace “English” with whichever written—and/or spoken—human language you want.)

Our best computers today are babies! So talk to them using the same words and sentence composition as you would a young child. A language world where even “Run Dick, Run!” is a needlessly over-complicated expression that you can reduce still further:

Run Dick.

Or, for absolute precision (which machines do like):

Tell Dick to run.

An artificial language, stripped down to its absolute minimum; all non-irreducable complexity gone. Simple verb-noun compositions. A spitting image of the “small childrens’ language” we already use with our own biological spawn.

And once you’ve learned how to talk to your machine as you would any toddler; and the two of you can successfully negotiate and arrive at a common understanding of what you actually want it to do, you’ll have cracked the problem way better than the self-driving throw-AI-pixie-dust-at-it contingent ever will. Because you will have learned how to do pedagogy, and learned how to reach that common agreement in the simplest way possible.