XML programming languages????

Ok, WTF? Guy Steele Jr. is a pretty bright guy. I’m just getting into LISP
beyond the lightweight knowledge I had for tweaking emacs, and I have a
glimpse of what he’s talking about in LISP with extending the language.
Heck, it goes WAY beyond that. The article I refer to by Mr. Steele is here

There’s a really good quote about LISP, of which I dug up an incarnation
by John Foderaro here.

“…Lisp is a programmable programming language. Not only can you
program in Lisp (that makes it a programming language) but you can
program the language itself.”

Steele figures that the language will represent as XML due to the
popularity and tools available for it. XML will represent the structure
and higher abstractions in the language, and the syntax and onscreen
representation will become merely a view on the structure represented in
the XML. I think I get where he’s coming from, and there’s some merit
there, but I think that’s like saying C++ macros are as powerful as
defmacro in LISP. XML is hierarchical. It’s not freely associable, and
can’t being to represent effectively or efficiently something on the
order of what a language such as LISP does. There’s a disconnect in
level of abstraction and power there that I can’t effectively explain at
this juncture, but it’s there.

Programmers are starting to understand higher and more powerful levels
of abstraction, design, and systems. I think more people would grasp
LISP at a deeper level now than when it was introduced. I also think
that by and large, most developers still fundamentally won’t get it. The
majority of developers, even GOOD developers, just don’t think that way,
which is closer to why LISP, especially LISP in the fullest sense, just
didn’t go mass-market the way C and C++ (and Java) did.

I think Steele has a kernel of a good idea, in that it seeks to get the
structure, intent and design of the program into a form that can be
manipulated as the proverbial model in the MVC, and allow us to make
that view into a variety of representations beyond our convential view
of syntax. On that level, I completely agree that we need such a system,
but there’s a lot of groups trying to do that, and it’s complex.
Reducing it to XML is like saying the BNR of the system is all that’s
represented. That’s not a higher level. That’s machine code. We need to
be thinking at a higher level than that. We don’t need a representation
of our languages to be some slick transformable version of pretty. We
need those ideas and modules to be represented as groups and modules,
and ways of working with those groups and modules the way we work with
strings and ints. Steele has the right grit in the idea, especially with
the intro about the UNIX command line. But the power there is that those
strings and such are usually themselves the higher chunks of ideas, and
using those tools on basic sentences and dictionaries or using them to
format, sort, edit and update cross-references and bibliographies is
equally simple.

The difference in my mind is that the higher abstraction is that chunk
that the computer isn’t dealing with the in the case of the command
line. The chunks the filters and programs process are arbitrary
complexity. We need the system for defining, manipulating the
association of the filters, of the filters themselves, and of the
behaviour of the shell itself. That’s a big step above where we’re at,
and it’s what I would call System Syntax, as opposed to Language Syntax.

It’s there. You can see the outline by the topics that seem to be
gaining steam in our craft. Domain Languages. Language Oriented
Programming. Model Driven Design. Unlike 4GL and CASE tools, we are
approaching it as building layers of abstraction as opposed to the
ultimate syntax processor and generator. We’ve got the syntax processors
and generators in languages, compilers, virtual machines and runtime
environments. Components were clumping the syntax bits together. We
still don’t have a way of clumping ideas and processing chunks together
the way you can abstract an entire category of algorithms with a LISP
macro. It’s a totally different level.

Maybe Steele’s approach is a first step, or at least another path to
wander down to better understand the problem and find a solution. I just
think it’s somewhat the wrong direction, but hey, he’s got more cred
than I do. But I still trust my instincts.

Got a comment on this? Sorry, but the bloged system I’m fiddling with
doesn’t deal with that. Email me instead for now at (dallas (A) hockley
(DOT) ca). If I actually GET some comments, I may look into a comment
system as that would be an indicator this went beyond a diary. -)

Keep on thinking!

Leave a Reply

Your email address will not be published. Required fields are marked *