Kaz Kylheku

[John Thingstad]

I have noticed you have become dramatically better in Lisp in a relative
short period of time.
What is you "secret"?

--------------
John Thingstad

[Kaz Kylheku]

On Apr 18, 6:10 am, "John Thingstad" <jpth...@online.no> wrote:
> 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]

Kaz Kylheku <kkyl...@gmail.com> writes:
> 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]

On 19 Apr, 04:28, Kaz Kylheku <kkylh...@gmail.com> wrote:

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