Pascal, Oberon and Ada were left out of the options, yet quite a few companies do their business selling tooling on this space. And regarding Java, there are other alternatives.
Names are hard I guess. But if you're going to pick a [letter][number] name it'd be hard to come up with one that has a worse naming collision.
Apple's moved on to T2 in their current machines, so beyond "Isn't that Apple's old security chip?" questions it probably won't run into much overlap, but first thought was "is this Apple releasing something related to the T1 chip?"
"T" beats it when you search for T0 programming language on google, so I don't think that was a good idea either.
As far as I can tell T0 doesn't exist anywhere online, unless I'm confused and it's actually this Scheme dialect from 1982 and T0 is a specific version number under that?
The slides indicated they were contemplating very small systems without an MMU or memory protection. Without those, a null pointer dereference may not be able to generate an exception.
Personally I don't mind unusual syntax. I do find it a bit problematic that programming languages seem to select syntax almost at random, or at least they don't tend to spend a lot of time explaining it [0]. A lot of special characters can quickly become less pleasant with a non-English keyboard however. Especially if the syntax is hard to predict (with for example autocomplete).
It seems strange to call out Ada for "unexplained" and "unusual" syntax. The syntax is very similar to the syntax of Pascal, which was an enormously popular language at the time when Ada was designed.
I meant that Ada does explain its syntax (at least partly in that pdf), but many languages don’t seem to. And when they do I can more easily accept whatever it is. It is when the syntax seems random I can’t wrap my head around it.
I don't mind unusual syntax as long as it looks like C, so to speak. (C is weird, but I'm used to it, and context switching is easier the more similar a syntax is to C.)
I would consider the `Deref` trait as well as the liberal use of `Into` etc in libraries to fall under this category. Not _fully_ automatic, but generally not clear from the callsite (which, in the case of `Deref`, is the `.` operator).
They want to promote their own language and wanted at least two reasons against Rust (the first with lack of LLVM support for many smaller embedded platforms is true).
To me Rust is much easier to understand than C++. But C is still more straightforward.
https://www.mikroe.com/mikropascal
http://www.astrobe.com/default.htm
http://www.microej.com/
https://www.aicas.com/cms/
https://www.ptc.com/en/products/developer-tools/perc
https://www.ptc.com/en/products/developer-tools/apexada
https://www.ghs.com/products/ada_optimizing_compilers.html
https://www.adacore.com/