> A slightly off-subject remark:
> I think all XML-based programming languages (like XSLT) are seriously handicapped by the verbosity of XML.
> This seriously limits their acceptance by non-XML-specialists.
Isn't this too simplistic? XSLT is not a general purpose design, it is optimized for a particular use: semi-structured documents.
When you try to do the conversions that XSLT is good for in general languages (e.g. using iterators rather than XPath) they
are much more verbose. And ditto with the reverse: if you are just doing toy XML with relational data the conventional
languages (and GraphQL) will be easier.
Every programming language (except pure LISP) is a mix of different notations. In XSLT this is very explicit: you have two syntaxes: the elements
and attributes including {} as the wrappers, the XSLT as the query language including a sublanguage for regular expressions. Ditto Schematron.
Take Java: it has a mix of one syntax for infix expressions, and another for assignment, another for annotations, another for declarations, another for
regular expression, and so on. People usually like the sugar: if it looks slightly different it reminds them that it has a different purpose. People find
pure LISP difficult because there is no sugar to differentiate different kinds of ), at the opposite extreme.
So the designer choice is what syntaxes they use at each level of their language. For example, you could have an C#-in-XML that just had a wrapper
element and elements for regions: that would be an "XML" programing language but only just. Personally, I think that XML is perfectly suitable for
everything at the method level (i.e. classes, regions, methods, Documentation) but not suitable at the expression level, for a general purpose language:
if you have something big that you want to call out its end, XML is fine; if you have things that don't nest then XML is indeed verbose.
And XML has a big problem, with requiring < to be delimited, which makes it cumbersome for development in text editors.
But why not just think in terms of an external form and an internal form: define a friendly syntax, then have a reliable transformation to and from an
XML form, so you can get the best of both worlds? (I.e. a layered version of what SGML provided built-in with SHORTREFs)
The other angle is that what is "verbose" is now up for grabs, as editors get the Language Protocol implementations.
Cheers
Rick
