So a while back Nathan made a post about playing with macros. Since I have wanted to start playing with lisp for a while and I finally got slime going at home, I thought this would be as good a jumping in point as any.

My first endevors where to simply recreate what Nathan had written with out cheating too much. I ended up getting it pretty much right, except that I had missed a #' on the memoize call. Since this had taken relativly little time, I converted the macro to use gensyms, and tried to think of something else to do. One of the things that always intrigued me a little was the way that symbols are strings that can be manipulated like most anything else. Memoizing is a pretty basic caching scheme, but it was missing something: the ability to clear the cache.

I decided that I would make defmemoize create two functions; one that would call the original function memoized, and one that would clear that functions cache.

On my first attempt, it became pretty obvious that I didnt have a clue about the timing of this. So I sat down to reconsider what I was doing and realized that, if I was going to declare memoize (the function) in local scope, I needed to move that into the backquoted area. The reason to declare the function in local scope, is that we can pull the cache hashtable out into a slightly larger local scope so that my clear-cache function has access to the same hashtable. This lead to version 2..

Now that I had everything scoped correctly, I needed to figure out why my symbol munging wasnt working. Nathan was working with me and he suggested that I use intern instead of make-symbol. This sort of worked, except that rather than the symbol I wanted, I got the symbol I wanted inside of pipes (ex: foo-clear-cache -> |foo-clear-cache|). After some mucking about and trying different things, Nathan noticed that the example code was using capital letters in the keyword arguments. This combined with playing with the function for a few minutes, revealed to him, that if the string we are trying to symbolize is in all caps when we intern it, it comes without pipes. Glad LISP is case insensitive, except when it isnt.

After, we figured out the symbol munging, the last thing I had to do was figure out which symbols should be #' when passed to funcall and which shouldnt. While a little arduous do to CL's 2 cell system, I finally managed to work it out in my final version. Along the way I came up with a little test script that allowed me to verify that both functions were working.

Over all, I am liking LISP a lot, but there is definatly a learning curve. I am hoping that now that I have gotten my feet wet a bit, I will be able to get into it a little more.

Hashtable Source

 var x = new Object()  
 var y = new Object()  
>> [object Object] 
 z = new Object()  
>> [object Object] 
 x[y] = 'test' ;
>> test
 x[z]  
>> test 

• Total music: Between 50 and 100 gigs spead all over everywhere (Work/Home/CDs Yet to be ripped. Its really hard to give a better guess since there is a lot of overlap between places)
• Song playing now: Nathan talking over Carmina Burana's quiet parts.
• Five Pieces of Music that I listen to a lot or just that I like alot
  1. The Complete Works of Miles Davis ( This isn't really a single piece of music, but I figure with all of the other "Complete" Miles box sets, it's just a matter of time. Top place goes between Kinda of Blue and Bitches Brew )
  2. And All That Could Have Been - Nine Inch Nails (The song or the Album your choice.)
  3. Binaural - Pearl Jam (This is kinda a temporary thing since I like pretty much everything they put out. This is just what Ive been listening to most, recently
  4. Carmina Burana - Carl Orff
  5. A few things to hear before we all blow up - Williamson (this is the most peaceful techno I've ever heard)