Kaz Kylheku
John Thingstad
short period of time.
What is you "secret"?
--------------
John Thingstad
Kaz Kylheku
> I have noticed you have become dramatically better in Lisp in a relative
> short period of time.
Not recently, however. The period of time which fits your observation
is from sometime early 2001 when I picked up Lisp for the first time,
through 2002. In early 2003, I was already rewriting the buggy
backquote expander for CLISP.
> What is you "secret"?
Part of the "secret" is something that we all know: Lisp is pretty
easy.
The other part of the secret is that I ``greenspunned'' a lot of the
things that are in Lisp.
Take a look at http://users.footprints.net/~kaz/mpp.html
This silly project was written before I knew anything about Lisp. Yet
it contains elements like:
- symbol data type, with a name property;
- namespaces mapping names to symbols;
- everything is a nested list of items;
- ``eval'' function (item_eval)
- based on lists, not text source code
- no heavyweight abstract syntax nodes, just lists
- interning identifiers to symbols
- read tables (copied from TeX)
- scanned characters assigned to categories
- user programmable
- local, lexically-scoped macros a la macrolet and symbol-macrolet
- environments
- concept of a binding as an association
between a symbol and memory location
which references a value.
So passage into Lisp was something that was practically necessary; as
you can imagine, I felt right at home.
Pascal Bourguignon
> For a good laugh, you should see this old project, hosted on my old
> website. Keep in mind that I knew nothing about Lisp at all when I
> wrote this:
>
> http://users.footprints.net/~kaz/mpp.html
>
> There are no links to it because it's kind of embarassing. The
> internals of this program are heavily greenspunned:
>
> - everything is nested lists containing heterogeneous objects of type
> ``item''.
> - readtables
> - lexically scoped local macros. I had never seen this anywhere,
> but it corresponds to Common Lisp's SYMBOL-MACROLET.
> - macros that compute list structure, rather than strings.
> - items are part of an object-oriented system hacked up in C.
> - items have operations structure containing function pointers, and
> one of these is ... eval!
> - the concept that eval takes an item as its input, and produces a
> list of items, not like eval in the Bourne shell or perl, etc.
> - symbol type with a string as its name, and a polymorphic value
> cell!
There's no reason to be ashamed, on the contrary.
You should heavily publicize that project, and give it as an example
of why lisp is superior to C/C++/...
> [...]
> So as you can see, I was a pretty good fit for becoming a Lisp
> programmer. I found a lot of familiar things in Lisp, but put together
> in a way that was far more complete, robust and easier to understand
> and use, than anything I had come across before.
--
__Pascal Bourguignon__ http://www.informatimago.com/
"A TRUE Klingon warrior does not comment his code!"
Spiros Bousbouras
> The other part of the secret is that I ``greenspunned'' a lot of the
> things that are in Lisp.
>
> Take a look athttp://users.footprints.net/~kaz/mpp.html
>
> This silly project was written before I knew anything about Lisp.
I've just downloaded it and will play around with
it eventually. It doesn't look silly. Any chance
you'll complete the tutorial eventually ?