Where do these guys come from?

8 views
Skip to first unread message

Peter Seibel

unread,
Jan 18, 2005, 8:39:29 PM1/18/05
to

From an article "Extensible Programming for the 21st Century" from ACM
Queue by Gregory V. Wilson, University of Toronto. After starting his
article with a quote from *Guy* *Steele*, he says this:

This article argues that next-generation programming systems can
accomplish this by combining three specific technologies:

o Compilers, linkers, debuggers, and other tools that are
frameworks for plug-ins, rather than monolithic applications.

o Programming languages that allow programmers to extend their
syntax.

o Programs that are stored as XML documents, so programmers can
represent and process data and meta-data uniformly.

These innovations will likely change programming as profoundly as
structured languages did in the 1970s, objects in the 1980s, and
components and reflection in the 1990s.

Bah.

-Peter


--
Peter Seibel pe...@javamonkey.com

Lisp is the red pill. -- John Fraser, comp.lang.lisp

Peter Seibel

unread,
Jan 18, 2005, 9:11:04 PM1/18/05
to
Peter Seibel <pe...@javamonkey.com> writes:

> From an article "Extensible Programming for the 21st Century" from ACM
> Queue by Gregory V. Wilson, University of Toronto.

Forgot the URL:

<http://www.acmqueue.com/modules.php?name=Content&pa=printer_friendly&pid=247&page=1>

Andrew

unread,
Jan 18, 2005, 10:10:16 PM1/18/05
to
Peter Seibel wrote:
> Peter Seibel <pe...@javamonkey.com> writes:
>
>
>>From an article "Extensible Programming for the 21st Century" from ACM
>>Queue by Gregory V. Wilson, University of Toronto.
>

From page 3: "Programmers have been joking for decades that Lisp stands
for "lots of irritating single parentheses." Behind those jokes lies a
profound idea: in Lisp, programs and data are both represented as nested
s-expressions. This encourages Lisp programmers to think of programs as
data and to manipulate them the same way they manipulate everything else.

Most programmers turned up their noses at Lisp's prefix notation and
parentheses. Those same programmers, however, have raced to adopt XML. "

So I think he comes from Canada somewhere (based off of where he went to
school, mostly) :-)

Peter Seibel

unread,
Jan 18, 2005, 10:17:52 PM1/18/05
to
Andrew <acri...@PLEASEDONTSPAM.gmail.com> writes:

> Peter Seibel wrote:
>> Peter Seibel <pe...@javamonkey.com> writes:
>>
>>>From an article "Extensible Programming for the 21st Century" from ACM
>>> Queue by Gregory V. Wilson, University of Toronto.
>>
>
> From page 3: "Programmers have been joking for decades that Lisp
> stands for "lots of irritating single parentheses." Behind those
> jokes lies a profound idea: in Lisp, programs and data are both
> represented as nested s-expressions. This encourages Lisp programmers
> to think of programs as data and to manipulate them the same way they
> manipulate everything else.
>
> Most programmers turned up their noses at Lisp's prefix notation and
> parentheses. Those same programmers, however, have raced to adopt
> XML. "

Yeah, I did a quick search for Lisp and thought he hadn't mentioned it
at all before I noticed that the paper was split over multiple pages
(even in the "printer friendly" version!) But the fact remains that
his list of the characterestics that he claims are going to break all
this new ground are essentially a description of Lisp except using
XML.

Andrew

unread,
Jan 18, 2005, 10:22:48 PM1/18/05
to
> Yeah, I did a quick search for Lisp and thought he hadn't mentioned it
> at all before I noticed that the paper was split over multiple pages
> (even in the "printer friendly" version!) But the fact remains that
> his list of the characterestics that he claims are going to break all
> this new ground are essentially a description of Lisp except using
> XML.

Yeah, I agree. If we were crafty, though, we would probably make a lisp
compiler that read xml instead of sexprs, call it Seaweed, and be the
next big thing. I suspect a lot of academic people have had this idea
themselves, which is another theory as to why lisp keeps getting
reinvented. I happen to like the smug-lisp-weenie theory that lisp is
the global maxima for programming languages myself, though.

Andy

Frank Buss

unread,
Jan 18, 2005, 10:37:50 PM1/18/05
to
Peter Seibel <pe...@javamonkey.com> wrote:

> Peter Seibel <pe...@javamonkey.com> writes:
>
>> From an article "Extensible Programming for the 21st Century" from
>> ACM Queue by Gregory V. Wilson, University of Toronto.
>
> Forgot the URL:
>
> <http://www.acmqueue.com/modules.php?name=Content&pa=printer_friendly
> &pid=247&page=1>

the rest of the article is missing, the full version is better:

http://www.third-bit.com/~gvwilson/xmlprog.html

Some quote from the full version:

| Scheme proves by example that everything described in this article
| could have been done twenty years ago, and could be done today without
| XML.

--
Frank Buß, f...@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de

Peter Seibel

unread,
Jan 18, 2005, 10:52:56 PM1/18/05
to
Frank Buss <f...@frank-buss.de> writes:

> Peter Seibel <pe...@javamonkey.com> wrote:
>
>> Peter Seibel <pe...@javamonkey.com> writes:
>>
>>> From an article "Extensible Programming for the 21st Century" from
>>> ACM Queue by Gregory V. Wilson, University of Toronto.
>>
>> Forgot the URL:
>>
>> <http://www.acmqueue.com/modules.php?name=Content&pa=printer_friendly
>> &pid=247&page=1>
>
> the rest of the article is missing, the full version is better:
>
> http://www.third-bit.com/~gvwilson/xmlprog.html
>
> Some quote from the full version:
>
> | Scheme proves by example that everything described in this article
> | could have been done twenty years ago, and could be done today without
> | XML.

Ah, I recognize that--this came up a few months ago. I thought it was
*another* one. Just the same guy getting published in a new forum.
Sorry.

Pascal Bourguignon

unread,
Jan 18, 2005, 11:27:16 PM1/18/05
to
Andrew <acri...@PLEASEDONTSPAM.gmail.com> writes:

> > Yeah, I did a quick search for Lisp and thought he hadn't mentioned it
> > at all before I noticed that the paper was split over multiple pages
> > (even in the "printer friendly" version!) But the fact remains that
> > his list of the characterestics that he claims are going to break all
> > this new ground are essentially a description of Lisp except using
> > XML.
>
> Yeah, I agree. If we were crafty, though, we would probably make a
> lisp compiler that read xml instead of sexprs, call it Seaweed, and be
> the next big thing. I suspect a lot of academic people have had this
> idea themselves, which is another theory as to why lisp keeps getting
> reinvented. I happen to like the smug-lisp-weenie theory that lisp is
> the global maxima for programming languages myself, though.

Let's prepare for the big switch over:

(DEFUN STRING-REPLACE (STRING REGEXP REPLACE &OPTIONAL FIXEDCASE LITERAL)
"
RETURN: a string build from `string' where all matching `regexp'
are replaced by the `replace' string.
NOTE: Current implementat accepts only literal patterns as `regexp';
`fixedcase' and `literal' are ignored.
"
(DECLARE (IGNORE FIXEDCASE LITERAL) (STRING STRING REGEXP REPLACE))
(LOOP WITH REGEXP-LENGTH = (LENGTH REGEXP)
WITH RESULT = ""
WITH PREVIOUS = 0
WITH POSITION = (SEARCH REGEXP STRING)
WHILE POSITION
DO (SETQ RESULT (CONCATENATE 'STRING
RESULT (SUBSEQ STRING PREVIOUS POSITION) REPLACE)
PREVIOUS (+ POSITION REGEXP-LENGTH)
POSITION (SEARCH REGEXP STRING :START2 PREVIOUS))
FINALLY
(SETQ RESULT (CONCATENATE 'STRING RESULT
(SUBSEQ STRING PREVIOUS (LENGTH STRING))))
(RETURN RESULT)))


(defun pc-data (text)
(STRING-REPLACE
(STRING-REPLACE
(STRING-REPLACE (format nil "~A" TEXT) "&" "&AMP;" T T)
">" "&GT;" T T)
"<" "&LT;" T T))


(defun tag (tag &rest contents)
(format nil "<~A>~{~A~^ ~}</~2:*~A>" (string-downcase tag) contents))


(defun xml (tree)
;; TODO: circles
(cond
((null tree) (tag :null nil))
((complexp tree) (tag :complex
(tag :realpart (pc-data (realpart tree)))
(tag :imagpart (pc-data (imagpart tree)))))
((rationalp tree) (tag :rational
(tag :numerator (pc-data (numerator tree)))
(tag :denominator (pc-data (denominator tree)))))
((floatp tree) (tag :float (pc-data tree)))
((integerp tree) (tag :integer (pc-data tree)))
((stringp tree) (tag :string (pc-data tree)))
((symbolp tree) (tag :symbol (pc-data tree)))
((vectorp tree) (error "not implemented yet"))
((arrayp tree) (error "not implemented yet"))
((consp tree) (tag :cons
(tag :first (xml (car tree)))
(tag :rest (xml (cdr tree)))))
(t (error "~A not implemented yet" (type-of tree)))))


(defun print-xml (tree &optional (stream *standard-output*))
(princ (xml tree) stream))

(print-xml '(defun pc-data (text)
(STRING-REPLACE
(STRING-REPLACE
(STRING-REPLACE (format nil "~A" TEXT) "&" "&AMP;" T T)
">" "&GT;" T T)
"<" "&LT;" T T))) -->

<cons><first><symbol>DEFUN</symbol></first>
<rest><cons><first><symbol>PC-DATA</symbol></first>
<rest><cons><first><cons><first><symbol>TEXT</symbol></first>
<rest><null>NIL</null></rest></cons></first>
<rest><cons><first><cons><first><symbol>STRING-REPLACE</symbol></first>
<rest><cons><first><cons><first><symbol>STRING-REPLACE</symbol></first>
<rest><cons><first><cons><first><symbol>STRING-REPLACE</symbol></first>
<rest><cons><first><cons><first><symbol>FORMAT</symbol></first>
<rest><cons><first><null>NIL</null></first>
<rest><cons><first><string>~A</string></first>
<rest><cons><first><symbol>TEXT</symbol></first>
<rest><null>NIL</null></rest></cons></rest></cons></rest>
</cons></rest></cons></first>
<rest><cons><first><string>&AMP;</string></first>
<rest><cons><first><string>&AMP;AMP;</string></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><null>NIL</null></rest></cons></rest></cons></rest></cons>
</rest></cons></rest></cons></rest></cons></first>
<rest><cons><first><string>&GT;</string></first>
<rest><cons><first><string>&AMP;GT;</string></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><null>NIL</null></rest></cons></rest></cons></rest></cons>
</rest></cons></rest></cons></rest></cons></first>
<rest><cons><first><string>&LT;</string></first>
<rest><cons><first><string>&AMP;LT;</string></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><cons><first><symbol>T</symbol></first>
<rest><null>NIL</null></rest></cons></rest></cons></rest></cons>
</rest></cons></rest></cons></rest></cons></first>
<rest><null>NIL</null></rest></cons></rest></cons></rest></cons></rest></cons>


I wonder how I could live without distinguishing <symbol>T</symbol>
from <string>T</string>...

--
__Pascal Bourguignon__ http://www.informatimago.com/
Until real software engineering is developed, the next best practice
is to develop with a dynamic system that has extreme late binding in
all aspects. The first system to really do this in an important way
is Lisp. -- Alan Kay

Pascal Bourguignon

unread,
Jan 18, 2005, 11:37:58 PM1/18/05
to
Frank Buss <f...@frank-buss.de> writes:

> Peter Seibel <pe...@javamonkey.com> wrote:
>
> > Peter Seibel <pe...@javamonkey.com> writes:
> >
> >> From an article "Extensible Programming for the 21st Century" from
> >> ACM Queue by Gregory V. Wilson, University of Toronto.
> >
> > Forgot the URL:
> >
> > <http://www.acmqueue.com/modules.php?name=Content&pa=printer_friendly
> > &pid=247&page=1>
>
> the rest of the article is missing, the full version is better:
>
> http://www.third-bit.com/~gvwilson/xmlprog.html
>
> Some quote from the full version:
>
> | Scheme proves by example that everything described in this article
> | could have been done twenty years ago, and could be done today without
> | XML.

Another quote:

One of the other great ironies of the early 21st Century is that
it is trivial for secretaries to put cubicle floorplans in their
documents, but nearly impossible for programmers to put class
diagrams in code.

She does that with a software that's 50 to 150 MB big, with hundreds
or thousands of bugs. I'd rather use tools less than 10 MB with only
tens of bugs to write new programs. Let's maximize the ratio of of
bugs of human origin / bugs originating in buggy tools.

--
__Pascal Bourguignon__ http://www.informatimago.com/

This is a signature virus. Add me to your signature and help me to live

Cor Gest

unread,
Jan 19, 2005, 2:20:57 AM1/19/05
to

Someone referred to as: Frank Buss <f...@frank-buss.de>
has comitted the herein quoted text :

> | could have been done twenty years ago, and could be done today without
> | XML.

well , lets just scrap, the xml-junk out of the equasion then ...

(defparameter *strip-xml-parse-table*
#(((#\< . 1) 0) ; 0 - normal state
((#\! . 2) 5) ; 1 - after <
((#\- . 3) 5) ; 2 - after <!
((#\- . 4) 5) ; 3 - after <!-
((#\- . 8) 4) ; 4 - comment <!--
((#\' . 6) ; 5 - markup
(#\" . 7)
(#\> . 0)
5)
((#\' . 5) 6) ; 6 - markup, single-quote
((#\" . 5) 7) ; 7 - markup, double-quote
((#\- . 9) 4) ; 8 - comment, after -
((#\> . 0) (#\- . 9) 4) ; 9 - comment, after --(*)
))

(defun lookup-transition (state input)
(let ((transitions (svref *strip-xml-parse-table* state)))
(dolist (elt transitions)
(cond ((atom elt)
(return-from lookup-transition elt))
((char-equal input (car elt))

The rest should be data, should'nt it ....? ;-)

Cor

--
To really make a mess of things one should use a manager to instruct a computer

Holger Duerer

unread,
Jan 19, 2005, 7:32:26 AM1/19/05
to
>>>>> "Pascal" == Pascal Bourguignon <sp...@mouse-potato.com> writes:
[...]
Pascal> Let's prepare for the big switch over:
[... lotsa code deleted ...]

Of course case matters in XML, so it should be "&amp;" etc. not
"&AMP;". And you need the initial XML declaration.

Also, without indenting, your XML is really unreadable. Compare that
to my perfectly readable, re-indented version of your example:

,----
| <?xml version='1.0' encoding='UTF-8'?>

| <string>&amp;</string>
| </first>
| <rest>
| <cons>
| <first>
| <string>&amp;AMP;</string>

| <string>></string>
| </first>
| <rest>
| <cons>
| <first>
| <string>&amp;GT;</string>

| <string>&lt;</string>
| </first>
| <rest>
| <cons>
| <first>
| <string>&amp;LT;</string>

`----

Surely, this *is* the death of Lisp as we know it...

Holger

P.S.: Oh, yeah. Almost forgot: :-)

Paolo Amoroso

unread,
Jan 19, 2005, 7:57:47 AM1/19/05
to
Pascal Bourguignon <sp...@mouse-potato.com> writes:

> Another quote:
>
> One of the other great ironies of the early 21st Century is that
> it is trivial for secretaries to put cubicle floorplans in their
> documents, but nearly impossible for programmers to put class
> diagrams in code.

Is anybody working on themes?


Paolo
--
Why Lisp? http://alu.cliki.net/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools (see also http://clrfi.alu.org):
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- UFFI: Foreign Function Interface

Trent Buck

unread,
Jan 19, 2005, 9:24:53 AM1/19/05
to
Up spake Peter Seibel:
> [Code can now be written in XML. How innovative!]

This was predicted (if you read between the lines) by
http://c2.com/cgi/wiki?LispMachinesAreComingBack

...and the pages it links to.

<quote>
Alter your LISP interpreter to use angle brackets instead of parens, and
tell your PHB that it is the latest nestable incarnation of XML. Call it
`Enterprise XML 2.0' (EXML 2.0) and sell it for fifty grand.
</>

--
-trent

Wade Humeniuk

unread,
Jan 19, 2005, 11:12:41 AM1/19/05
to
Peter Seibel wrote:
>
> Bah.
>

I wish I had an easy answer, but it really has more to do with politics
than with science and rational thought. I have found that many
"computer people" are quite dangerous in that knowing a little they
think they know a lot. Dealing with these people can be very
frustrating since they usually defend their views with violence.
Reason takes a back door and their ideas come out cloaked in
jargon and psuedo logic and reason. I can see why someone like
Bill Gates is noted for being so forceful, they have to be to
deal with the nutballs.

I really think some of the blame can be attributed to the "computing
community", groups like the ACM and the IEEE. Their peer review
process is not brutal enough and they have let too much through.

Wade

Bulent Murtezaoglu

unread,
Jan 19, 2005, 11:52:22 AM1/19/05
to
>>>>> "WH" == Wade Humeniuk <whumeniu+...@telus.net> writes:
[...]
WH> I wish I had an easy answer, but it really has more to do with
WH> politics than with science and rational thought.

A good explanation on why the answer is not easy.

WH> I have found
WH> that many "computer people" are quite dangerous in that
WH> knowing a little they think they know a lot.

I don't know if it is that different in any other field. We assume it
yet when I whine in the presence of non-computer people, they say they
deal with the same thing.

WH> Dealing with
WH> these people can be very frustrating since they usually defend
WH> their views with violence.

You don't want to deal with them, you want to _compete_ with them. If
you can arrange that, that is.

[...]
WH> I really think some of the blame can be attributed to the
WH> "computing community", groups like the ACM and the IEEE.
WH> Their peer review process is not brutal enough and they have
WH> let too much through.

I wholeheartedly agree, except perhaps I'd change 'brutal' to 'sane and
responsible.' There's nothing brutal about calling a spade a spade.

cheers,

BM

Peter Scott

unread,
Jan 19, 2005, 1:00:25 PM1/19/05
to
Trent Buck wrote:
> <quote>
> Alter your LISP interpreter to use angle brackets instead of
parens, and
> tell your PHB that it is the latest nestable incarnation of XML.
Call it
> `Enterprise XML 2.0' (EXML 2.0) and sell it for fifty grand.
> </>

Not a bad idea. To get the base of it working, you would probably have
to define your own dialect of Lisp that was almost, but not quite,
entirely unlike Common Lisp and Scheme. This would decrease the chances
of people just dismissing it as a straight translation of CL or Scheme.
Then you would need a backend (I would probably use Bigloo scheme,
since it really is good at distribution), and a front-end that would
let you view it with conventional-looking syntax that looks like Ruby
or Python (preferably Ruby since Python's indentation thing is a
turnoff for many people for some reason) and which would let you mix in
XML fragments that could be processed with something analogous to
macros and allow people to define their own syntax for their XML
fragments. Rewrite some of the classic examples of Lisp macros in this
language and it should look pretty appealing.
I'll make millions!

-Peter

Richard J. Fateman

unread,
Jan 19, 2005, 1:06:49 PM1/19/05
to Peter Seibel
Why don't you write a letter to ACM Queue?

The original (on-line) paper appears to refer to
Lisp, as having said it all,
while the published paper refers to s-expressions,
in an otherwise very similar sentence.

You could, of course, also write to the author(s).

Peter Seibel

unread,
Jan 19, 2005, 1:26:24 PM1/19/05
to
"Richard J. Fateman" <fat...@eecs.berkeley.edu> writes:

> Why don't you write a letter to ACM Queue?

That is, of course, an eminently sensible idea. However I despair of
trying to find an argument that will fit in a letter to the editor
that won't just sound like sour grapes whining. Last time I tried to
make the case for Lisp I ended up writing ~400-500 pages. ;-)

Cesar Rabak

unread,
Jan 20, 2005, 10:57:11 AM1/20/05
to
Peter Seibel escreveu:

> From an article "Extensible Programming for the 21st Century" from ACM
> Queue by Gregory V. Wilson, University of Toronto. After starting his
> article with a quote from *Guy* *Steele*, he says this:
>
> This article argues that next-generation programming systems can
> accomplish this by combining three specific technologies:
>
> o Compilers, linkers, debuggers, and other tools that are
> frameworks for plug-ins, rather than monolithic applications.
>
> o Programming languages that allow programmers to extend their
> syntax.
>
> o Programs that are stored as XML documents, so programmers can
> represent and process data and meta-data uniformly.
>
> These innovations will likely change programming as profoundly as
> structured languages did in the 1970s, objects in the 1980s, and
> components and reflection in the 1990s.
>
> Bah.
Peter,

The only thing I could not grasp was the "Bah."

ROTFL

--
Cesar Rabak


Emre Sevinc

unread,
Jan 20, 2005, 12:24:03 PM1/20/05
to
Peter Seibel <pe...@javamonkey.com> writes:

> From an article "Extensible Programming for the 21st Century" from ACM
> Queue by Gregory V. Wilson, University of Toronto. After starting his
> article with a quote from *Guy* *Steele*, he says this:
>
> This article argues that next-generation programming systems can
> accomplish this by combining three specific technologies:
>
> o Compilers, linkers, debuggers, and other tools that are
> frameworks for plug-ins, rather than monolithic applications.
>
> o Programming languages that allow programmers to extend their
> syntax.
>
> o Programs that are stored as XML documents, so programmers can
> represent and process data and meta-data uniformly.
>
> These innovations will likely change programming as profoundly as
> structured languages did in the 1970s, objects in the 1980s, and
> components and reflection in the 1990s.

Looks like new QUEUE and old original (unmodified) article created
quite a discussion. I've met the original one some time ago, but
yes, having a version of it on ACM QUEUE is a good starting point
(or a reminder, anyway...).

I've seen at least two threads here in cll, the one I'm writing
in and the one by "taltman": "Slashdot: Greenspun's Rule In Action".

My evil plan is to translate some parts of the article into Turkish,
I mean some spot sentences, highlights, etc. Then pour oil on fire
by referring to discussions from here, quoting examples related to
Scheme, Lisp, angle brackets versus devilish (!) parantheses,
loathsome and dead Lisp machines but state-of-the-art and sexy
XML processing machines, etc.

Feel free to be my partner-in-crime and write down the parts
of the articles that you think most important, or criticisms
that you think most important, or some titles, etc. Of course
I'll try to summarize and provide reference to the articles
here but an overall summary, a compact and brief list of
criticisms would make my job a lot easier. So you heard my
offer and it is up to you if you want to help me spread the
word in a Turkish geek/nerd site http://fazlamesai.net in which
we started to publish some articles related to Common Lisp, installing
CL environment, etc. It was quite a shock to youngster and university
students who heard Lisp for the first time in their lives ;-)

By the way, I know at least one example from history
where people rediscovered things after so many years.
The shape of the earth and its circumference. An ancient
Greek philosopher had done some measurements in Alexandria
(I think it was around 300 B.C.) and claimed the circumference
of the planet to be a number which is very close to our
current measurements. And yes, he had Babylonian sources
to assume that the Earth may be spherical. And then guess
what happened? Yes, yes, we had to wait more than thousand
years, Galileo, etc. Why? To rediscover how earth looked
like, its shape! We people have a strong and full record
of forgetting important facts and rediscovering them after
so many years. Compared to that, the situation of Lisp
seems a little bit better, at least there are people
like Peter Seibel who are preparing for second Lisp revolution.


P.S.: Hey Peter, why don't you put an appendix at the end
and talk about LispMachinesAreBackButNotTheWayYouLikeIt ;-)

--
Emre Sevinc

eMBA Software Developer Actively engaged in:
http:www.bilgi.edu.tr http://ileriseviye.org
http://www.bilgi.edu.tr http://fazlamesai.net
Cognitive Science Student http://cazci.com
http://www.cogsci.boun.edu.tr

Jens Kilian

unread,
Jan 20, 2005, 12:27:24 PM1/20/05
to
Frank Buss <f...@frank-buss.de> writes:
> Some quote from the full version:
> | Scheme proves by example that everything described in this article
> | could have been done twenty years ago, and could be done today without
> | XML.

So the essence of XML is this: the problem it solves is not hard,
and it does not solve the problem well.

- Jérôme Siméon & Philip Wadler,
"The Essence of XML",
POPL 2003, New Orleans, January 2003.
--
mailto:j...@acm.org As the air to a bird, or the sea to a fish,
http://www.bawue.de/~jjk/ so is contempt to the contemptible. [Blake]

Pascal Costanza

unread,
Jan 20, 2005, 12:45:50 PM1/20/05
to
Jens Kilian wrote:
> Frank Buss <f...@frank-buss.de> writes:
>
>>Some quote from the full version:
>>| Scheme proves by example that everything described in this article
>>| could have been done twenty years ago, and could be done today without
>>| XML.
>
>
> So the essence of XML is this: the problem it solves is not hard,
> and it does not solve the problem well.
>
> - Jérôme Siméon & Philip Wadler,
> "The Essence of XML",
> POPL 2003, New Orleans, January 2003.

Also from Philip Wadler's website:
http://homepages.inf.ed.ac.uk/wadler/language.pdf

Pascal

Reply all
Reply to author
Forward
0 new messages