Lisp and languages in general

[RE01 Rice Brian T. EM2]

Hi all,

I can't connect to the Tunes server right now to check on the discussions,
but I thought it appropriate to mention a discussion I saw on the lambda
weblogs a few days ago. MIT had a Little Languages Workshop under the
Dynamic Languages group activity. Anyway, Paul Graham added something to
this discussion about a new Lisp that he was working on; it seems at about
the same level of development as Slate: a decent amount of Lisp code and not
much of a concrete design yet. Anyway, there's an essay reachable from the
following url:

http://lambda.weblogs.com/discuss/msgReader$2093

titled "Being Popular" which discusses interesting aspects of programming
language culture and how language design interacts with it. One point I
thought worth mentioning was that Lisp is quite a nice language as such, but
when in Lisp one finds oneself using sub-languages that aren't an extension
of Lisp itself. For example, string operations and escape sequences in Lisp
are exactly the same as one would find them in other languages, and often
less concisely-expressed. The Tunes aspect to this is that we don't have a
unified system here, which at first glance would mean that one would make,
as an example, a regexp-parser and manipulator out of the Lisp reader plus
some macros.

Something else that comes to mind for me is an article explaining
Quasiquotation (by Alan Bawden?) (a Citeseer search should pretty quickly
turn up the right result) where he mentions some of the questionability of
the logic of Lisp-style quotation, summarizing it as a "confusion of
reference and representation". This relates to string-manipulation since
programming languages obviously try to embed a representation of (what
should be the full class of) strings into program source code which is
itself a string. Since Tunes wants to move away from *relying on* text as a
program representation, this is relevant. I've said (possibly a year or two
ago) that a system of networking of quotation is probably the design goal,
taking as a template the idea of morphisms between categories. Obviously
this is very abstract, but Maude seems to use this in its "view" feature
quite naturally, and it's easily executable and re-used. The downside of the
use of Maude is the weighty syntax.

(Quasiquotation as a subject is interesting in its own right, as being a way
to use the Lisp reader plus macros to more easily manipulate
quotation-over-lists. Part of my suggestion here is that we should be
thinking about extending this towards quotation-over-(arbitrary shapes).
This sounds like it could be solved using some of the ideas about cata- and
ana- etc morphisms mentioned in a series of papers that I really need to
list out for you with the right .bib references. I'll mail about this later.
I'm sure Fare knows exactly what papers I'm talking about, I believe the
title "Programming using Algebraic Datatypes" is one of them.)

So a network of embeddings between classes of things is what I'm suggesting
is the right direction for us to look in as far as string literals or
whatever type of quotation one may want.

Side Note: I've been really busy these last couple of weeks, so my progress
on Arrow has been limited to just going over the research papers a few times
over to get my mind around the different concepts. I'm trying to come up
with a proper set of tools that emulate the needed semantics from Maude,
Lisp, etc that fit together properly, and still allow a good self-hosting.

Any questions about this quotation stuff and why it applies to how we use
strings, etc.?
~