Reddit Interview

David Newberger interviews Steve Huffman and Alexis Ohanian of reddit [via Zach Beane]:

I don’t regret writing reddit in Lisp at all. It’s a particularly good language for developing applications without a solid plan of where you’re going. Lisp never gets in the programmer’s way. However, sometimes (oftentimes, more like it) the environment does (again, lack of a strong community). We may rewrite reddit in something else as we bring on more programmers, but Lisp has certainly served as well up until this point.

I just can't believe there's a company called Blogniscient.

Fritz Kunze's Secrets

Franz' Fritz Kunze on the secrets of running a successful programming language business [via anarchaia]:

Programming language is a cult. It's a religion. Many programmers stick to one language and do not change it for 50 years, their entire career. So you have to be like a cult leader to gain a good user base.

[...]

Databases sells better than languages as product.

Try Ruby

Why the lucky stiff has created a beautiful interactive ruby lesson [it doesn't work very well in Safari yet; try Firefox].

See his notes on what people try to do with it:

>> while true; puts 'Joe Junkpan' end

I love it. That’s going to hurt you a lot more than it hurts me. Don’t forget not to type Symbol.all_symbols.

>> format c:
>> cd c:\
>> delete c:\

Oh no, my MP3s! My Usher collection! NO!

David Cohen, who showed me the page, said

First of all, this is fun and cool.

Second of all, it gets people (ok, it got me) over the issue of getting around to doing it--the instant gratification works wonders.

Third, perhaps someone should set something like this up for Lisp?

It got me to play with it.

Some Lispers are Retro

Nevermore is Alastair Bridgewater's TI Explorer Raven microcode emulator.

Meroko is another TI Explorer emulator, written by Daniel Seagraves.

Bill Bradford wants to port Brad Parker's MIT CADR emulator to OS X.

I personally have nearly zero interest in retro emulation of this sort. Maybe if Sea Dragon ran on these machines...

Learning Lisp for Free with MIT

Christopher Roach's widely linked article, “Learn Lisp From MIT—for Free!!!” pointed readers to the resources for a self-directed SICP-based Lisp (or Scheme) education: MIT's OpenCourseWare version of 6.001, DrScheme and the SICP lecture videos (and the RSS feed of the series optimized for iPods).

In “More Lisp—For Free”, Christopher, a newcomer to Lisp himself, spends a little more time on why it might be worth learning Lisp; including the beneficial effect it can have on your coding in other languages.

So, after a couple of failed attempts before this summer, I was pleasantly surprised when I finally found myself starting to grasp the concepts and I was actually able to start writing programs in Lisp. And, to my surprise, in a very short period of time, I was able to write programs faster and more bug-free than in other languages with which I was much more acquainted (e.g., C/C++, C#, and Java).

Now, I've never used Lisp in my professional life, however, I began to notice that some of the habits I picked up while programming in Lisp were creeping into my daily programming and were actually helping me out quite bit.

He wants to hear from people using Lisp, too.

Oh, and by the way, if any of you out there are using Lisp in your daily life, personal projects, professional projects, whatever, please, post a comment below giving us some of the juicy details. Feel free to talk about how hard it was, what advantages/disadvantages it provided, and/or provide links to websites about your project (especially those containing interesting source code).

Chicago Pride

Joyce catalogs the other University of Chicago alumni she's run across in the computer game lately.

Maybe the U of C AI lab of the mid-90's was a somewhat special place (Robin Hunicke is another alumnus I'll run into, inevitably, I am sure). And 37 Signals is singlehandedly causing me to question my assumption that no useful, fun, sophisticated web technology will come out of the city of Chicago.

It's funny—my initial, knee-jerk response to seeing a reference, in print, to my dropping out of grad school is shame. Part of me still tries to classify the experience as a failure, even though it was pretty clear right away that both being in school and dropping out were excellent choices. And now 10 years later I can look back and see that thank god I went, and thank god I quit. (This reminds me that Pinku recently saw my old grad advisor (and later, boss) recruiting for Google).

The story of Joyce's own descent into madness was recently featured at O'Reilly Radar as number two in their series on how various alpha geeks got into computers.

I wondered at first if the Valley could possibly have a place for a female 30-year-old recycled historian among all the CS grads, but I've found there's always room for someone who genuinely loves the Internet and wants to contribute. I've also been lucky in that the things I care about the most -- building social software apps, and the new architectures necessary to support the special demands of those apps -- are so new they aren't much taught in CS departments, so an academically trained computer scientist doesn't have much advantage in the field over someone like me.

I've seen the same thing, smart non-CS people being very successful in software.

Gary King's Code Bonanza

Gary King is releasing as open source a collection of code he's built up over the years.

He has a post describing how he used some of the code to visualize his del.icio.us tags.

The make-filtered-graph method takes a graph, a vertex filter, a completion style and a depth. In this case, we select the single vertex labeled "lisp" and go out to a depth of one. Then we include all of the links.

Xooglers

Erann Gat/Ron Garrret is posting the story of his Google experience to Xooglers, “a gathering spot for ex-Googlers to reminisce and comment on the latest developments in search” [via est].

I've been debating with myself whether or not to write about my Google experience at all. It seems like such a self-indulgent thing to do, and, while in retrospect it has certainly turned out quite well, there were some bumps along the way (to put it mildly) and I did some things that I'm not altogether proud of.

On the other hand, I've always enjoyed being on the receiving end of a good inside scoop, so now that I'm in a position to share an experience that others seem to care about I feel like I ought to do so. Besides, they say confession is good for the soul.

Also posting to Xoogler is Doug Edwards, Director of Consumer Marketing and Brand Management for Google from 1999 to 2005.

More from Erann:

Suffice it to say that I attributed a significant portion of my own professional success to my use of Lisp over the years, and I was loath to give it up. But the industry had moved definitively away from Lisp and towards C++ and, in the Web world, Java. I found both of these languages very difficult and frustrating to master, and that was a large factor in my decision to stay at JPL during most of the dotcom boom. Why should I submit myself to all that pain when I had a perfectly good job where I could do as I pleased?

Bug Outcomes

Hurricane Wilma in Cancun. Reminds me of the beach in Merida.

Timboy analyzes bug outcomes, and proposes a few new types of resolution.

BREAKITDOWN - This bug seems to be multiple bugs in one -- refile individually
SCALEITBACK - This bug is breathtaking in its ambition and scope -- try a version for humans
DEFINESUCCESS - This bug doesn't seem to have an endpoint. Refile with a description of what it would mean to close the bug

Ruby

Rick Bradley makes me want to try Ruby and Ruby on Rails.

Rails is not a Silver Bullet. However, widely reported results place productivity increases over modern Java methodologies (e.g., J2EE, Struts, etc.) in the 6-fold to 10-fold range (with many of these claims coming from long-time Java luminaries). Preliminary tests by our Technical Lead put the code reduction for a normal module in our Java stack converted to Rails at roughly 20:1.

Sounds awfully fun. On hiring:

I’ve personally found it’s much easier to find the “smart people” we’re looking for in the Ruby community since the community seems to be self-selecting the smart folks—that is, that the likelihood some random person I run into in the Ruby community is highly experienced, smart, and adaptable, is much greater than the likelihood of saying the same with people selected at random from, say, the Java community.

Wiki Spam Fighter

I mocked up an interface to a possible anti-wiki abuse tool.

The idea was to make it easier to delete the kind of spam the ALU Wiki gets, which seems to be from a person using a single IP address, laboriously editing pages and satisfying captchas challenges.

There's some more discussion of the issues at the ALU Wiki Meta-discussion page.

I wanted to use logs of actual spamming efforts to make sure that grouping changes by IP address would in fact be useful, so I scraped the recent changes page. I decided to try Manuel Odendahl's html-match library to assist with the scraping, and despite it taking some time to figure out how to do what I wanted (there isn't much in the way of documentation, at least in English), it ended up saving me a lot of effort.

(html-match:html-pattern
    (html-match:+or ((:div :id "recentchangesdateheader") ?thing)
            ((:div :id "recentchangesblock") ?thing))
    (let ((day (day-p ?thing)))
      (if day
          (setf date-string day)
          (let ((change (parse-changes ?thing date-string)))
        (when change
          (push change changes))))))

I did find a few minor bugs in the Kiwi code running the ALU Wiki while working on this. Along with one inexcusable bug for a web-based application: incorrect HTML entity handling.

Lore at Oki Dog: Corpse of a Corpse

This morning Lori and I had dim sum with Lore and Colette at Empress Pavilion, but it wasn't enough to stop Lore from making a pilgrimage to Oki Dog a few hours later.

I couldn't possibly explain why I eat these, any more than I can explain why they exist. Oki Dog calls to me as I cruise the freeway into LA. I don't think I could eat one anyone else in the world.

The Melvins and Scott Kelly

Wednesday night, neck and I saw The Melvins with Jello Biafra at the Henry Ford theater. I never listened to The Melvins and had no idea what they were like; neck said they were extremely heavy and we had to see them. He was right. Smoking.

And the pairing with Jello worked well. This was the first time I'd ever seen Jello Biafra, and I couldn't believe it when he broke into “California Über Alles”! And then “Chemical Warfare”! And then “Holiday in Cambodia”! It was like some unexpected weird closure to the memory of listening to Dead Kennedys LPs 20 years ago in wintery Illinois.

Thursday was a day of rest, then last night we went out again to see Scott Kelly (of Neurosis) do an excellent show at the Knitting Factory. Spare, intense music from a very humble guy. Scott gave us CombatMusicRadio.com shirts, so I guess I'll have to listen to him do his net radio thing there.

Exscribe

François-René Rideau's Exscribe is “a document authoring tool programmed and programmable in Common Lisp.”

Now, there already exist a few other document authoring systems that are programmable; but the way they are programmed is always a gross kluge, in a mess of a language that was never designed, never selected, and lacks the basic features required of any serious programming language. Their programming capability capability stems from an overgrown collection of badly interacting “scripting” features, special-purpose “macro” languages, and exotic specialer-purpose virtual-machines. The most widespread programmable authoring tool, LaTeX, comes to mind; it is a collection of gross hacks, layered on top of each other, in a way hopelessly beyond any kind of salvation. Scribe, being programmable using a dialect of a real, decent programming language, namely Lisp, was a beacon of light in the dark chaos of authoring tools

Fare mentions some surprising performance implications of using an extended version of the host language, Common Lisp, as the document description language.

Where Exscribe spends over 98% its computation time (excluding the admittedly slow FASL loading), is compiling the Exscribe code. Indeed, the whole point of Exscribe is that your documents are Common Lisp programs, evaluated by your Common Lisp implementation. And here, the optimizing compilers will spend a lot of time trying to optimize code that is only going to be run once, whereas interpreters do the right thing of not wasting time optimizing it. That's why clisp is so good, and also why cmucl is good: cmucl includes an interpreter to be used in those situations, whereas sbcl dumped this interpreter away and its eval always calls the optimizing compiler.

I'm surprised OpenMCL didn't perform better; I've always thought of its compiler as being extremely fast.

Format Stinks

Drew McDermott thinks format stinks. And he has an alternative.

He takes on what Guy Steele called “the hairiest format control string I have ever seen,” used for printing the xapping data types in Connection Machine Lisp:

----------------------------------------------------------------
Table 22-8: Print Function for the Xapping Data Type

(defun print-xapping (xapping stream depth) 
  (declare (ignore depth)) 
  (format stream 
          ;; Are you ready for this one? 
          "~:[{~;[~]~:{~S~:[->~S~;~*~]~:^ ~}~:[~; ~]~ 
           ~{~S->~^ ~}~:[~; ~]~[~*~;->~S~;->~*~]~:[}~;]~]" 
          ;; Is that clear? 
          (xectorp xapping) 
          (do ((vp (xectorp xapping)) 
               (sp (finite-part-is-xetp xapping)) 
               (d (xapping-domain xapping) (cdr d)) 
               (r (xapping-range xapping) (cdr r)) 
               (z '() (cons (list (if vp (car r) (car d)) 
                                  (or vp sp) 
                                  (car r)) 
                            z))) 
              ((null d) (reverse z))) 
          (and (xapping-domain xapping) 
               (or (xapping-exceptions xapping) 
                   (xapping-infinite xapping))) 
          (xapping-exceptions xapping) 
          (and (xapping-exceptions xapping) 
               (xapping-infinite xapping)) 
          (ecase (xapping-infinite xapping) 
            ((nil) 0) 
            (:constant 1) 
            (:universal 2)) 
          (xapping-default xapping) 
          (xectorp xapping)))

Drew says “Folks, you don't have to put up with this nonsense. Here is the civilized way to write the print-function.”

(defun print-xapping (xapping stream depth)
   (declare (ignore depth))
   (out (:to stream)
      ;; Print ``['' for a xector, and ``{'' otherwise. 
      (:q ((xectorp xapping) "[")
      (t "{"))

      ;; Print the pairs implied by the xapping.
      ;; Whether the element to the left of the arrow comes from
      ;; the list 'd' or the list 'r' depends on whether the
      ;; xapping is a xector.  An arrow is printed only if
      ;; xapping is not a xector or a xet.  The element to the
      ;; right of the arrow always comes from 'r'.
      ;; Each pair is followed by a space, except the last.
      (:e (do ((vp (xectorp xapping))
           (sp (finite-part-is-xetp xapping))
           (d (xapping-domain xapping) (cdr d))
           (r (xapping-range xapping) (cdr r)))
          ((null d))
         (:o (if vp (car r) (car d))
         (:q ((not (or vp sp)) "->"))
         (car r)
         (:q ((not (null (cdr d))) " ")))))

      ;; If there were pairs and there are exceptions or an infinite part,
      ;; print a separating space. 
      (:q ((and (xapping-domain xapping)
        (or (xapping-exceptions xapping)
            (xapping-infinite xapping)))
       " "))

      ;; Given a list of exception indices, print them.
      (:e (do ((el (xapping-exceptions xapping) (cdr el)))
          ((null el))
         (:o (car el)
         (:q ((not (null (cdr el))) " ")))))

      ;; If there were exceptions and there is an infinite part,
      ;; print a separating space.
      (:q ((and (xapping-exceptions xapping) (xapping-infinite xapping))
       " "))

      ;; The infinite part is omitted if nil, printed as "->k" if it's a
      ;; constant k, and printed as "->" if it's "universal"
     (:e (ecase (xapping-infinite xapping)
        ((nil))
        (:constant (:o "->" (xapping-default xapping)))
        (:universal (:o "->"))))

     ;; Print ``]'' for a xector, and ``}'' otherwise. 
     (:q ((xectorp xapping) "]")
     (t "}"))))

Lx

Lx is Norman Gray's SAX-compatible reader for an sexpr-based XML syntax.

Another way of looking at this is that Lx provides a notation for XML in lisp-style sexps, similar in some ways to SXML, though that's mostly concerned with going the other way. Or, put yet another way, this is a sexp-to-SAX converter in Java.

Here's the XSLT identity transformation:

;; The XSLT identity transformation
(lx:namespace ((#f "http://www.w3.org/1999/XSL/Transform"))
  (stylesheet version: 1.0
    (template match: "node()|@*"
      (copy
        (apply-templates select: "@*|node()")))))

This is pure XSLT, and would be accepted as such by any XSL transformation engine which allows you to plug in an alternative parser.

Short Course of Lisp

Robert Sayre talks a bit about Yahoo 2.0, DSLs and Sawzall. He also proposes an intense curriculum for learning Lisp.

On Lisp is so far right up there with the best programming books I have ever read. In fact, I've made it part of a little table that shows how you should learn about Lisp coding. They get harder as you move down, so you should probably start at the top, unless you're one of those people who knows a lot of this stuff through other languages already, in which case you can read SICP and Lisp In Small Pieces at the same time, and then work backwards.

Practical Common Lisp	SICP (also with excellent video courses)
On Lisp
Lisp In Small Pieces

Birthday #35

On Saturday night Lori and I had a big ol' joint birthday party. It was our first party in our new apartment, and it turned out pretty well. There were probably 50 or 60 people, with lots spilling out into our courtyard and driveway.

Lori wrote up a little thing about the party, and took a bunch of pictures. Ally said some nice things about it, too.

I was a bit overwhelmed by it all, frankly. I remember things pretty clearly before the party started, watching the Star Wars Holiday Special with Ally, Mike, Lori and neck, but then... I only have an hour's worth of memories to cover the next six hours. And I only had one drink.

Maybe it's cheesy, but I can't help but view that party as a milestone. Three and a half years ago I moved to LA to start a new job. I knew two people in town. I was afraid of how things would turn out. Now I'm successfully running my own little business and I'm friends with a frightening number of top shelf people—generous, passionate, creative people.

I think it's important to realize how good my situation is, and enjoy it.

And then, of course, one can't help but wonder what's next.

SLIME Screencast Review

Scott Reynan on the SLIME screencast:

After watching a screencast demonstrating SLIME, or Superior Lisp Interaction Mode for Emacs, I have a much clearer idea of how much I want to use this technology: not at all.

Granted, I skimmed a lot of the fifty-five minute video on creating a morse code translator (and they say Lisp isn't useful). But when the narrator says, fifty minutes in, "this example is so simple that I can just look at it, and I know exactly what is going on," I think it comes very close to a perfect definition of irony. And then at the end, when he tries to quit and everything goes haywire, it's just pure comedy.

Dude. You should have seen ILISP.

SLIME, despite being kind of complicated and somewhat brittle (when a project recommends you use the version from CVS, that's definitely a smell of some kind, code or otherwise), is pretty good and without a doubt the best thing the free Lisps have. I do think the GUI environments provided by some of the commercial implementations remain superior in some ways, but even when using those implementations there are still times that it's nice to have a rich emacs interface.

New Powerbook

Last week the display on my 3.5-year-old 15" titanium Powerbook fritzed out, so I got a new 15" aluminum Powerbook— basically the same one John Gruber recently reviewed. I agree with pretty much everything he said.

The good: 1. The CPU is twice as fast as my old machine, which is nice, but I think the biggest speedup comes from the 7200 RPM Seagate hard drive. It's about 3x as fast as my old 5400 drive, and much quieter. 2. Going to 1.5 GB of RAM actually made a big difference over the 1 GB I had in the old machine. 3. The incrementally higher resolution is incrementally nicer (and the people complaining on Macintouch and returning their laptops because of “horizontal lines” in the display are kooks). 4. The backlit keyboard really is useful. 5. It does feel sturdier than the Ti book. 6. OS X's Setup Assistant completely cloned my old powerbook; all I had to do was reinstall Xcode.

The bad: 1. Twice I've had to reboot because the mouse got jumpy and the kernel_task process went a little out of control. It looks like this is a driver issue with the new touchpad hardware, and I hope it's resolved in an OS update.

Joel Spolsky at LispNYC

Smart developers ∩ Windows Programmers ∩ Lisp Fans ∋ Joel Spolsky.

First, Joel lets it be known that he's tried Lisp in a Box, and has read Practical Common Lisp. Then he gets Paul Graham to insult Wall Street people on video. Now he's talking at tonight's LispNYC meeting (“This month's presentation is about next-generation language design and why Lisp is relevant by Joel Spolsky”).

CL-XMPP

cl-xmpp is a Lisp implementation of the Jabber protocol the open standard for instant messaging (used by Google Talk). It works with SBCL, LispWorks and ACL (and soon OpenMCL). It doesn't yet include SSL support, which is required by Google Talk.

I'm embarrassed that Lispers writing software requiring nothing fancier than XML parsing, sockets and SSL have to work so hard to support multiple platforms. The Lisp model worked for us decades ago, but I think its time of maximum usefuless has passed.

SICP Lectures on Your iPod

Max Khesin converted the Abelson & Sussman SICP lecture videos to a video iPod-friendly format and created an iTunes-friendly RSS feed to automatically download and sync them to your iPod [via Gavin]. Total convenience, man.

Lispjobs Feed

Lispjobs.com now has an Atom feed. Which is good, because at this point there are only two or three sites for which I actually fire up a browser to check for new stuff.

(I had to upgrade my NetNewsWire to 2.0.1; 2.0 couldn't understand the Atom 1.0 feed.)

Telematics 2.0

Reading the Techcrunch description of Ajay Juneja's natural language interface to his car was a weird sort of deja vu.

He’s layered a proprietary dialog manager, which semantically parses and analyzes data, on top of off-the-shelf speech recognition software, to create one kick ass computer system that is controlled with an array microphone. It allows you to control your car via speech. It was jaw-droppingly impressive.

For the demo, Ajay controlled his stereo system verbally, changing songs, picking tracks, controlling volume, etc. The commands he used to do this were in absolutely plain English and varied considerably in structure. For instance, Ajay at one time said “go to track 3″. Another time he said “play for me another one bites the dust”. Later, “I would like to hear wonderful tonight by eric clapton. “louder”. “quieter”.

We were doing almost exactly the same thing at I/NET around 2001. I wonder if his system engages in the sort of disambiguating dialog we had.