- reading the source of cl-ppcre, which illustrated

     - run-time compilation (to chains of closures) without using
       COMPILE or COMPILE-FILE

     - parsing regular expression strings, with nice error-reporting
       via conditions

     - that Lisp solutions to practical problems can be concise,
       comprehensible, and *fast*

   - reading Keene's CLOS book

   - finding an application of continuable errors; it replaced a
     convoluted scheme of checking return values at multiple levels
     with a simple handler-bind wrapper.

   - realizing that file formats and communication protocols are just
     bits on disk or on a wire or sometimes even in memory, and Lisp
     is pretty good at generating the right bits and octets; inspired
     by (among other stuff):

     - learning that CLX is a Lisp program, not a binding to the C xlib

     - learning that Marc's CL-PDF is a Lisp program

     - learning about Frode's binary-types

     - reading Peter's chapters on parsing binary files

   - reading Will Hartung's "Guerilla Lisp Opus"

   - realizing that most Common Lisp implementations are mostly
     written in Common Lisp

A few themes:

   - Despite conceptually understanding how tools like CLOS and
     closures and conditions work, it took a tricky problem solved
     neatly by the tool to really make an Aha! moment

   - Aha! moments have made complicated tasks simpler and
     unapproachable tasks approachable (given the right amount of time
     and effort). They take the magic out of things. (Philip Greenspun
     used to say that his course would teach undergrads how to build
     Amazon in a semester; despite the hyperbole, it really did take
     the mystery out of how useful web applications can be
     constructed.)

Advice:

   - Be actively curious about how interesting things work ("how can
     cl-ppcre be faster than Perl?")

   - Be broadly aware of the tools available, and don't worry about
     immediate application

   - Don't settle for tedium (it's hard to have a breakthrough if you
     have resigned yourself to something that feels substandard)

   - People who write one interesting thing usually keep it up; find
     and watch interesting people (trickle-down Aha! effect?)

Minor delights:

   - format tricks (~v and ~{~^~} specifically)

   - inspecting a GF object in slime

What are some of the things that triggered your own Aha! moments? What
sort of stuff delighted you when you discovered it? What advice would
you give people who want to have more Aha! moments?

   - seeing the output of DISASSEMBLE for the first time (it was on a
     native-compiling Lisp), and the realization that the
     functionality is part of standard CL

- learning what generic functions are and what you can do
  with them in CLOS (e.g. the different kinds of specializers)

- the MOP (and every MOP-related thread in this newsgroup is
  making me aware that I'm still hanging onto preconceived
  notions about OOP)

- incremental programming with SLIME

For instance, in most other programming languages, new abstractions are
built by writing code on /top/ of existing abstractions. But in lisp,
its possible to build new abstractions by writing code *beneath*
existing code.

Here's an example (in scheme):

(define (square x) (* x x))
(define (power x n)
  (cond ((= n 0) 1)
        ((odd? n) (* x (power x (- n 1))))
        (else (square (power x (/ n 2))))))

This is a simple function which raises x to the integer power n, with a
minimum number of multiplications. (let ((x 5)) (power x 3)) returns
125.
Now its possible to make the same piece of code return optimized
symbolic output by just writing a new implementation of '*' !

(power 'x 3)  ->  (* x (* x x))

See the original article by Darius Bacon for the details:
http://cybertiggyr.com/gene/peval/peval.cgi

Learning that Eric Marsden's "PG" talks the PostgreSQL socket
protocol directly, and is not a binding to "libpq.so".

-Rob

--
Reply-To email is ignored.

--
Reply-To email is ignored.

Well, :Slime 2005-04-27 is there in my usual Emacs setup - I just don't
actively or consciously use it. C-h m shows reports no mode specifics. C-h
a slime lists very many slime commands. What Swank is I have no idea.

Slime is a superior interaction mode, yet it doesn't show up as a mode.
How Slime helps with "incremental programming" thus remains a mystery.

(asdf:operate 'asdf:load-op :swank)
(swank:create-swank-server 4005)

Then do M-x slime-connect from emacs. Open up a source file. Modify a
function and type C-c C-c and the new version is compiled into your
enviroment.

Petter