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 peter@javamonkey.com

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

From:	Peter Seibel
Subject:	Re: Where do these guys come from?
Date:	Wed, 19 Jan 2005 02:11:04 GMT

Peter Seibel writes:

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

Forgot the URL:

-Peter

--
Peter Seibel peter@javamonkey.com

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

From:	Peter Seibel
Subject:	Re: Where do these guys come from?
Date:	Wed, 19 Jan 2005 03:17:52 GMT

Andrew writes:

> Peter Seibel wrote:
>> Peter Seibel 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.

-Peter

--
Peter Seibel peter@javamonkey.com

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

From:	Andrew
Subject:	Re: Where do these guys come from?
Date:	Tue, 18 Jan 2005 21:22:48 -0600

> 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 prs, 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

Peter Seibel wrote:
> Andrew writes:
>
>
>>Peter Seibel wrote:
>>
>>>Peter Seibel 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.
>
> -Peter
>

From:	Pascal Bourguignon
Subject:	Re: Where do these guys come from?
Date:	19 Jan 2005 05:27:16 +0100

Andrew 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 prs, 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) "&" "&" T T)
">" ">" T T)
"<" "<" T T))

(defun tag (tag &rest contents)
(format nil "<~A>~{~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) "&" "&" T T)
">" ">" T T)
"<" "<" T T))) -->

DEFUN
PC-DATA
TEXT
NIL
STRING-REPLACE
STRING-REPLACE
STRING-REPLACE
FORMAT
NIL
~A
TEXT
NIL

&
&AMP;
T
T
NIL

>
&GT;
T
T
NIL

<
&LT;
T
T
NIL

NIL

I wonder how I could live without distinguishing T
from T...

--
__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

From:	Frank Buss
Subject:	Re: Where do these guys come from?
Date:	Wed, 19 Jan 2005 03:37:50 +0000 (UTC)

Peter Seibel wrote:

> Peter Seibel writes:
>
>> From an article "Extensible Programming for the 21st Century" from
>> ACM Queue by Gregory V. Wilson, University of Toronto.
>
> Forgot the URL:
>
> > &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ß, fb@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de

From:	Pascal Bourguignon
Subject:	Re: Where do these guys come from?
Date:	19 Jan 2005 05:37:58 +0100

Frank Buss writes:

> Peter Seibel wrote:
>
> > Peter Seibel writes:
> >
> >> From an article "Extensible Programming for the 21st Century" from
> >> ACM Queue by Gregory V. Wilson, University of Toronto.
> >
> > Forgot the URL:
> >
> > > > &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

From:	Cor Gest
Subject:	Re: Where do these guys come from?
Date:	19 Jan 2005 07:20:57 +0000

Someone referred to as: Frank Buss
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