···········@gmail.com wrote:
> I cannot find the link, nor remember where I read it, but at one time
> I came across a fun little story about how lisp macros began. The
> story discussed some programmers who were writing code and who soon
> began leaving little TODO notes in their code. Then the TODO notes
> became more explicit instructions on what to do, and then (I think)
> they eventually wrote a program (or extended their compiler) to
> process their TODO's and actually write the program code for them.
>
> Any clues as to where I might find the text of that would be
> appreciated. Thanks.
I heard that too. Perhaps asking at comp.lang.lisp would be a better
place, as there are more old timers there. ;)
On Apr 25, 9:10 am, namekuseijin <···················@gmail.com>
wrote:
> ···········@gmail.com wrote:
> > I cannot find the link, nor remember where I read it, but at one time
> > I came across a fun little story about how lisp macros began. The
> > story discussed some programmers who were writing code and who soon
> > began leaving little TODO notes in their code. Then the TODO notes
> > became more explicit instructions on what to do, and then (I think)
> > they eventually wrote a program (or extended their compiler) to
> > process their TODO's and actually write the program code for them.
>
> > Any clues as to where I might find the text of that would be
> > appreciated. Thanks.
>
> I heard that too. Perhaps asking at comp.lang.lisp would be a better
> place, as there are more old timers there. ;)
PCL has a story:
http://www.gigamonkeys.com/book/macros-defining-your-own.html
Lars Rune N�stdal wrote:
> On Apr 25, 9:10 am, namekuseijin <···················@gmail.com>
> wrote:
>> ···········@gmail.com wrote:
>>> I cannot find the link, nor remember where I read it, but at one time
>>> I came across a fun little story about how lisp macros began. The
>>> story discussed some programmers who were writing code and who soon
>>> began leaving little TODO notes in their code. Then the TODO notes
>>> became more explicit instructions on what to do, and then (I think)
>>> they eventually wrote a program (or extended their compiler) to
>>> process their TODO's and actually write the program code for them.
>>> Any clues as to where I might find the text of that would be
>>> appreciated. Thanks.
>> I heard that too. Perhaps asking at comp.lang.lisp would be a better
>> place, as there are more old timers there. ;)
>
> PCL has a story:
> http://www.gigamonkeys.com/book/macros-defining-your-own.html
Hah, probably just a tale, as it seems to be the only reference. Still,
not that far fetched on how it began. May it be he was talking about
MacLisp? :)
I think it's just a tale.... but it's here:
http://www.gigamonkeys.com/book/macros-defining-your-own.html
in Practical Common Lisp by Peter Seibel.
ttyl,
Patrick
On Apr 25, 9:44 pm, Patrick Stein <····@csh.rit.edu> wrote:
> I think it's just a tale.... but it's here:
>
> http://www.gigamonkeys.com/book/macros-defining-your-own.html
>
> in Practical Common Lisp by Peter Seibel.
>
> ttyl,
> Patrick
I don't remember exactly where I read this (might have been David
Touretzky's "Common Lisp: A Gentle
Introduction to Symbolic Programming") but here's what I think is the
TRUE story of macros:
Both defun and defmacro produce code that binds a lambda expression to
the symbol-function of a symbol, and does a bit more of fiddly stuff.
Originally, defun capabilities were as they are today, but there was
no "defmacro": you just had to write all the thorny code yourself.
Somebody eventually wrote a macro -- the long way -- for producing
this wrapper code for macro production -- in other words, somebody
wrote the defmacro macro, in the original defmacro-free syntax. This
first true macro-defining macro was eventually formally adopted into
Lisp.
I do however think that the "Story of Mac" is much better :)
From: Pascal J. Bourguignon
Subject: Re: help finding the fable of how lisp macros began
Date:
Message-ID: <87skjwbk5l.fsf@galatea.local>
Adlai <·········@gmail.com> writes:
> On Apr 25, 9:44�pm, Patrick Stein <····@csh.rit.edu> wrote:
>> I think it's just a tale.... but it's here:
>>
>> http://www.gigamonkeys.com/book/macros-defining-your-own.html
>>
>> in Practical Common Lisp by Peter Seibel.
>>
>> ttyl,
>> Patrick
>
> I don't remember exactly where I read this (might have been David
> Touretzky's "Common Lisp: A Gentle
> Introduction to Symbolic Programming") but here's what I think is the
> TRUE story of macros:
>
> Both defun and defmacro produce code that binds a lambda expression to
Before macros were FEXPR, and these existed at the very beginning of
LISP, at least since LISP 1.5.
> I do however think that the "Story of Mac" is much better :)
Indeed.
--
__Pascal Bourguignon__
In article <··············@galatea.local>,
···@informatimago.com (Pascal J. Bourguignon) wrote:
> Adlai <·········@gmail.com> writes:
>
> > On Apr 25, 9:44�pm, Patrick Stein <····@csh.rit.edu> wrote:
> >> I think it's just a tale.... but it's here:
> >>
> >> http://www.gigamonkeys.com/book/macros-defining-your-own.html
> >>
> >> in Practical Common Lisp by Peter Seibel.
> >>
> >> ttyl,
> >> Patrick
> >
> > I don't remember exactly where I read this (might have been David
> > Touretzky's "Common Lisp: A Gentle
> > Introduction to Symbolic Programming") but here's what I think is the
> > TRUE story of macros:
> >
> > Both defun and defmacro produce code that binds a lambda expression to
>
> Before macros were FEXPR, and these existed at the very beginning of
> LISP, at least since LISP 1.5.
Later came macros, but they didn't have all the &keywords or
destructuring that DEFMACRO provides. They simply received the entire
original form as a single parameter (this is still available via
DEFMACRO's &whole keyword), and you had to pull it apart. There also
was no backquote, so you had to do lots of detailed list construction (I
remember macros that used SUBST quite a bit).
Until DEFMACRO came along, it was rare to find many complex macros, it
was just too much of PITA. DEFMACRO was to Lisp what sexual
reproduction was to life, it ushered in a quantum leap in complexity.
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***
Barry Margolin <······@alum.mit.edu> writes:
> In article <··············@galatea.local>,
> ···@informatimago.com (Pascal J. Bourguignon) wrote:
>
>> Adlai <·········@gmail.com> writes:
>>
>> > On Apr 25, 9:44 pm, Patrick Stein <····@csh.rit.edu> wrote:
>> >> I think it's just a tale.... but it's here:
>> >>
>> >> http://www.gigamonkeys.com/book/macros-defining-your-own.html
>> >>
>> >> in Practical Common Lisp by Peter Seibel.
>> >>
>> >> ttyl,
>> >> Patrick
>> >
>> > I don't remember exactly where I read this (might have been David
>> > Touretzky's "Common Lisp: A Gentle
>> > Introduction to Symbolic Programming") but here's what I think is the
>> > TRUE story of macros:
>> >
>> > Both defun and defmacro produce code that binds a lambda expression to
>>
>> Before macros were FEXPR, and these existed at the very beginning of
>> LISP, at least since LISP 1.5.
>
> Later came macros, but they didn't have all the &keywords or
> destructuring that DEFMACRO provides. They simply received the entire
> original form as a single parameter (this is still available via
> DEFMACRO's &whole keyword), and you had to pull it apart. There also
> was no backquote, so you had to do lots of detailed list construction (I
> remember macros that used SUBST quite a bit).
Wow. All that *does* sound like a massive pain.
> Until DEFMACRO came along, it was rare to find many complex macros, it
> was just too much of PITA.
Well, it's called the Heroic Age for a reason...
> DEFMACRO was to Lisp what sexual reproduction was to life, it
> ushered in a quantum leap in complexity.
It also makes the neighbors think we're a bunch of weirdos, but they
just don't know what they're missing. ;)
On Apr 25, 2:44 pm, Patrick Stein <····@csh.rit.edu> wrote:
> http://www.gigamonkeys.com/book/macros-defining-your-own.html
>
> in Practical Common Lisp by Peter Seibel.
Yes! Thanks, Herwig, Lars Rune, and Patrick for finding it!