Thoughts on Data Escaping

For a system to need a means of escaping data is usually a sign of poor design, a sign that what the
system does and how it's expressed mismatch, a sign of greater flaws lurking somewhere else therein.

In particular, all programming languages express computation and yet use an approximation of a human
written language as their medium; this allows for ``syntax errors'' and whatnot to abound, and makes
using them less pleasant, compared to a system which manipulates their true semantic units directly.
Still, some are worse than others, and those using fewer arbitrary choices are generally better than
the rest.  A Forth has very little syntax, and APL's symbols were grandfathered into other character
sets.  Something which divides all languages into two camps are strings, in how they're represented.

The problem is simple: Strings are typically delimited by double or single quotation marks, and that
matter of representing the delimiter inevitably comes up.  Languages which simply ignore the problem
to provide no direct means of representing such strings are both the most pure and the least common;
however, I'm not aware of languages taking this route.  I strongly believe the superior camp are the
languages representing such strings as the concatenation of two; that is, that delimiter is repeated
without spacing to achieve such; APL is one language in this camp.  That inferior camp then would be
languages which pick an arbitrary ``escape character'' solely for the purpose, and this character is
typically the ``backslash'' character; it's a black mark upon Common Lisp for it to be in this camp.
The ``escape character'' solution requires the character itself to be escaped, and it's not uncommon
for other ``escape sequences'' to be added since there are already two at that point.  The arbitrary
nature of this design is what sickens me about it the most, and this nature is what reveals the rot.

A not-quite-pure method for string escaping is to allow single or double quotation marks to be used,
with the expectation that a string needing one mark will use the other, but this solution only kicks
the can down the road, and isn't complete in itself.  It's regardless not an unacceptable shorthand.

Data escaping is furthermore a source of inefficiency, and flaws brought about due to its lack where
expected.  In programming languages, it's expected but, in protocols and whatnot, it's unacceptable.
It's not hard to avoid in-band signalling when designing a protocol, but it can be easier, to fools,
to do it anyway.  There's no dearth of examples where such has allowed uninvited system control, and
malfunction.  I'd need to be shown a problem requiring it, in order to believe it to be permissible.
.