OT: Punctuation-starved Programming Languages

[Don Y]

Sean Conner wrote:
> It was thus said that the Great Don Y once stated:
>> So, the question:  are (were) there any useful languages
>> designed that did not rely heavily on punctuation in their
>> syntax?  It almost seems an inconsistency -- older languages
>> tended to be skimpy in their syntax (e.g., short identifiers,
>> global scope, etc.) which would suggest that punctuation
>> exploits would be MORE valuable to them.
> 
>   I wouldn't say that short identifiers, global scope, etc. are restrictions
> on syntax per se, but as a limitation due to the capacities of the computers
> at the time (like the 6 character limit of identifiers in C [1]).  But that

Yes -- but much of the syntax was undoubtedly influenced by
the capabilities of machines available at those times.  Though
I suspect some was just the author(s) taking poetic liberties
(e.g., Algol's ::= )

> aside, I can only think of a few that did not rely upon punctuation that
> much.  COBOL is one (although I don't know it well enough to say).  Pilot
> maybe.  BASIC is another one that can get by with minimal punctuation
> (parenthesis and brackets notwithstanding).  And it would be fairly trivial
> to remove punctuation from Forth with the proper word definitions.

Amusingly, *except* for parens, LISP largely does without punctuation!
Unfortunately, parens are a royal PITA as they require tracking
more state than local punctuation.

>   Then there's always assembly ... 

Not a very expressive language.  :>  Also, many assembly languages
use LOTS of special punctuation to reference indirection, auto
{in,de}crement addressing, parameter separators, comment
introducers, etc.

>   -spc (Do you have some special interest in this?)

Yes.  I was working on crafting an application specific language
and ran into the paren issue (yet again -- this comes up often
when designing such languages).  It made me wonder if someone
hadn't previously come up with a way to avoid this issue
(parens are a complication for the compiler/interpreter as well
as for the *user*).

A quick survey of the languages that I am familiar with led
me to the observations in my original post.  In particular,
that newer languages seem to be *more* heavily dependant on
punctuation (Limbo, Java, C++, Bongo, Python, etc.).  So,
I mused as to whether going *backwards* (in time) would
uncover a kinder, simpler language...

(of course, taking GREAT care to avoid APL on the way *back*!)

:>