Then that’s not an issue of the language, it’s an issue of the novice’s conceptualisation and understanding of the language.
Yes, it does come up a lot, but to the extent it has really just become something that’s echoed and passed on as de facto truth. But I’m not in any way suggesting that anyone who claims it is difficult is somehow wrong, or lying, or stupid. Not at all. Everyone finds different things difficult or easy, even experienced programmers who are only used to one type of language paradigm (often the case), finds switching to another kind challenging. A good example is the challenge many experienced coders have when they first attempt a functional language after being used to only imperative ones.
So it’s these statements that I’m not agreeing with. Yes, applications can definitely create their own terminology. But they absolutely cannot make the way the language is compiled and executed result in a different outcome that they’ve tailored to their own whims, which is what it sounds like you might be suggesting.
The application will have its own commands, many unique to it by name. But, it can’t decide to include a command that only accepts parameters written vertically. Every command is strictly defined by a name, which you look up in the dictionary; and it can optionally take a direct parameter, which it will indicate in the dictionary; and then a bunch of labelled parameters, each of which is labelled and typed in the dictionary.
The only other thing I can think of that has some variation between apps is to do with whether or not core suite commands are implemented and available. Some apps allow you to call open location
with it, some don’t. And the level of dereferencing that takes place when an application returns a collection of objects is something that one needs to experiment with to determine what can be done with the collection afterwards, in terms of applying other commands to the items as a collection of individually in a repeat loop. But that’s not unusual at all.
Yes, it does. As someone who has learned foreign languages, whether I pick up a philosophy book in German or an instruction manual for television in German, the language follows the same grammatical rules (more so than English). The style is different, of course; but if I learn to read an instruction manual in German, I can most certainly read and understand the content of the philosophy book in German. I may not have come across the word Philosophie in the instruction manual, but I can sound the word out and look it up in a dictionary. I don’t claim to understand the philosophical concepts being discussed in German, but that’s wouldn’t be related to my German language ability, but rather my knowledge around philosophy.
And computer languages are actually processed and learned by humans in the same way as spoken or written languages, and target the same areas of the brain. The evolution and structuring of language syntaxes also appear to be homeomorphic to each other.
Although this will be less true in the near future and already is in some cases, for now, computers are very precise, very predictable, and very structured with the way they process instructions and carry them out. Therefore, even if someone arsehole developer wanted to make life as hard as possible for us like Apple is doing with everything they can think to deprecate, they wouldn’t physically be capable of getting a machine to receive an instruction and have it carry out that instruction differently. AppleScript’s language parser isnt sufficiently advanced or adaptive to be able to cope with anything that isn’t well defined to it, even if it appears ill-defined to human eyes at first. Indeed, the structure of Apple events themselves, whilst hideous, is nonetheless extremely consistent and logical. One way that could demonstrate how underwhelmingly regular AppleScript is as a language is to write scripts using the raw chevron syntax. This removes the terminology clutter, which I think is what throws some people in terms of how the language looks on first glance. But as all chevron codes are either 4 or 8 character codes attached to a finite set of named wrappers (event
, handler
, constant
, class
, script
, property
and data
), without changing anything else, it’s immediately clear that there’s a one-to-one relationship between the language words and the terminology used to invoke them.