Just a quick example of list comprehensions in Clojure.

;; generate all the positions on a chess board:
(for [file "ABCDEFGH"
      rank (range 1 9)]
  (format "%c%d" file rank))
;; ("A1" "A2" "A3" "A4" "A5" "A6" "A7" "A8" 
;;  "B1" "B2" "B3" "B4" "B5" "B6" "B7" "B8" 
;;  "C1" "C2" "C3" "C4" "C5" "C6" "C7" "C8" 
;;  "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" 
;;  "E1" "E2" "E3" "E4" "E5" "E6" "E7" "E8" 
;;  "F1" "F2" "F3" "F4" "F5" "F6" "F7" "F8" 
;;  "G1" "G2" "G3" "G4" "G5" "G6" "G7" "G8" 
;;  "H1" "H2" "H3" "H4" "H5" "H6" "H7" "H8")

(count  (for [file "ABCDEFGH"
              rank (range 1 9)]
          (format "%c%d" file rank)))
;;64

;; the pythagorean triples example:
(for [aa (range 1 10)
      bb (range 1 10)
      cc (range 1 10)
      :when (= (* cc cc)
               (+ (* aa aa)
                  (* bb bb)))]
  (list aa bb cc))
;; ((3 4 5) (4 3 5))

;; all permutations?
(defn all-permutations [things]
  (if (= 1 (count things))
    (list things)
    (for [head things
          tail (all-permutations (disj (set things) head))]
      (do
        (cons head tail)))))

(all-permutations '(a b c))
;; ((a c b) (a b c) (b a c) (b c a) (c a b) (c b a))

;; This is a typical usage, for pulling apart a list                                                                         
(destructuring-bind
      (first second)
    '(1 2)
  (format t "~%~%;;; => first:~a second:~a~&" first second))

;;; => first:1 second:2                                                                                                      

;; You can also pull apart improper lists:                                                                                   
(destructuring-bind
      (first . second)
    '(1 . 2)
  (format t "~%~%;;; => first:~a second:~a~&" first second))

;;; => first:1 second:2                                                                                                      

;; The first argument to destructuring-bind is a lambda list, but you                                                        
;; can grab the remainder by either using a dotted list:                                                                     

(destructuring-bind
      (first second . stuff)
    '(1 2 3 4 5)
  (format t "~%~%;;; => first:~a second:~a rest:~a~&" first second stuff))

;;; => first:1 second:2 rest:(3 4 5)                                                                                         

;; or you can grab the remainder with &rest, just like you do for                                                            
;; functions that take a variable number of arguments:                                                                       
(destructuring-bind
      (first second &rest stuff)
    '(1 2 3 4 5)
  (format t "~%~%;;; => first:~a second:~a rest:~a~&" first second stuff))

;;; => first:1 second:2 rest:(3 4 5)                                                                                         

;; It really is a lambda list, you can use default parameters:                                                               
(destructuring-bind
      (first second &optional (third 'default))
    '(1 2)
  (format t "~%~%;;; => first:~a second:~a third:~a~&" first second third))

;;; => first:1 second:2 third:DEFAULT                                                                                        

(destructuring-bind
      (first second &optional (third 'default))
    '(1 2 3)
  (format t "~%~%;;; => first:~a second:~a third:~a~&" first second third))

;;; => first:1 second:2 third:3                                                                                              


;; And you can use keyword parameters:                                                                                       
(destructuring-bind
      (first second &key third)
    '(1 2 :third 3)
  (format t "~%~%;;; => first:~a second:~a third:~a~&" first second third))

;;; => first:1 second:2 third:3                                                                                              




;; Finally, you can use it to 'unparse' trees as well, which is a                                                            
;; really great feature, since your variable declaration matches the                                                         
;; 'shape' of the data strucutre you're pulling apart.  This technique                                                       
;; is really handy for dealing with XML after it's been converted to                                                         
;; s-expressions.                                                                                                            
(destructuring-bind
      (a (b (c d e (f g) h i j)) &rest remainder)
    '(1 (2 (3 4 5 (6 7) 8 9 10)) 11 12 13 14 15)
  (format t
          "~%~%;;; => a:~a b:~a c:~a d:~a e:~a f:~a g:~a h:~a i:~a j:~a remainder:~a ~&"
          a b c d e f g h i j remainder))

;;; => a:1 b:2 c:3 d:4 e:5 f:6 g:7 h:8 i:9 j:10 remainder:(11 12 13 14 15)                                                   

(require :drakma)
(require :landmark-parser)

(use-package :landmark-parser)

(defvar *doc* (drakma:http-request "http://www.loc.gov/standards/iso639-2/php/code_list.php"))

(defun get-main-table (doc)
  (extract-between
   (new-parser doc)
   '((forward-past "<table ")
     (forward-past "<table ")
     (forward-past "<tr")
     (forward-to "<tr"))
   '((forward-to "</table"))))
                      
(defun get-rows (block)
    (extract-all (new-parser block)
                 '((forward-to "<tr"))
                 '((forward-past "</tr>"))))
                                   
(defun row->cells (row)                                                                                                   
  (extract-all (new-parser row)    
               '((forward-past "<td")
                 (forward-past ">"))
               '((forward-to "</td>"))))

(with-open-file (out "/home/mortis/iso.tab"
                     :direction :output
                     :if-exists :supersede)
  (loop for row in (mapcar #'row->cells (get-rows (get-main-table *doc*)))                                                
     do
       (format out "~{~a~^      ~}~&" row)))

I just uploaded the Landmark Parser tonight.

sub makeDoOnce {
  my($sub) = @_;
  my $alreadyDone = undef;
  my @result      = undef;
  my $exception   = undef;
  return sub {
    die $exception if $exception;
    if ($alreadyDone) {return wantarray ? @result : $result[0];}

    eval {
      my $w = wantarray;
      if (not defined $w) {             $sub->(@_)}
      if ($w)             {@result    = $sub->(@_)}
      else                {$result[0] = $sub->(@_)}
    };
    $exception = $@ if $@;
    die $exception if $exception;
    $alreadyDone = 1;
    return wantarray ? @result : $result[0];
  };
}

I've just opened the book Dive into Python by Mark Pilgrim. The first example is a function that creates a (database?) connection string. Knowing Perl, I wrote a close equivalent so I could look at the differences.

First, the Python:

def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.

    Returns string."""

    return ";".join(["%s=%s" % (k,v) for k,v in params.items()])

if "__main__" == __name__:
    print buildConnectionString({
            "server":"localhost",
            "database":"master",
            "uid":"sa",
            "pwd":"sekret"
            })

Ok, defines a function of one parameter (buildConnectionString) - and that parameter is called out in the signature. This leads me to suspect that Python may actually know that the function takes a single argument (though not it's type), and that information may be available to the runtime (this is the kind of thing that helps IDEs and other software tools).

Within that function we can provide a docstring. This is something I'm familiar with from Common Lisp and it's a feature that I like. I suspect that I'll find that this is available in the Python runtime later on...

Then Mr. Pilgrim immediately indoctrinates us to Python's list comprehensions. Good. We can see that literal strings have methods (we're calling .join on the literal ";"), so they're an object (in Perl strings are not). I'm not sure what params.items() returns yet - a flat list? A set of pairs? I'm sure this is waiting for me on the next few pages.

Ok, this is a simple enough task, and the code is nice and succinct. The list comprehension makes the task clear (at least to me). What does the equivalent Perl look like? (well, my equivalent Perl, this is _my_ way of doing it, TIMTOWTDI after all).

use strict;
use warnings;

=head2 buildConnectionString                                                                                                 
                                                                                                                             
Build a connection string from a dictionary of parameters.                                                                   
                                                                                                                             
Returns string.                                                                                                              
                                                                                                                             
=cut                                                                                                                         
                                                                                                                             
sub buildConnectionString {
    my($params) = @_;
    return join(";",map { "$_=$params->{$_}" } keys %$params);
}

if (__PACKAGE__ eq "main") {
    print buildConnectionString({
        "server"   => "localhost",
        "database" => "master",
        "uid"      => "sa",
        "pwd"      => "sekret"
        }),"\n";
}

Ok, right off, I won't write Perl without the 'use strict;' and 'use warnings;' pragmas since they are big time savers. The first way in which they save time is that they help identify errors at compile-time that would otherwise be caught at run-time, and they point out conditions that you likely weren't handling (like using the contents of a variable before assigning to it).

Then there is the external documentation. My team has adopted the javadoc-like habit of making the api documentation in-line with the code. The difference here though is that there is no formal relationship between the POD and the function itself - unlike in the Python docstring (and in Javadoc, where adjacency is an implicit relationship). This means that the Perl documentation can't be (easily) the same kind of runtime value-add as the Python docstring (go Lisp).

The next thing is the function signature, or rather lack of, in the Perl function. Again, my team has adopted the convention of using a single line to do function argument destructuring - that way the first line of our functions is at least representationally equivalent to a signature. This makes our Perl applications a lot easier to read and maintain. Of course there are some cases (at least in Perl) when it can be useful to slightly modify the argument list, replace your function call with some other and pretend like the first never happened, though I'm not going into that right now. The main difference is that our convention isn't a formal part of the language, while in Python it is - and may additionally be a value-add at runtime (I'm sure I'll find out later, again, this is the kind of thing that helps IDEs and tools).

As far as the actual implementation, there is little logical or semantic difference between Perl's join/map and Python's join/list-comprehension. Perl's join is not a method. Neither uses an iterator off of the collection (as Ruby would), but both apply an operation to every (logical) item in a set (in the Python case it's a pair, though as I said I'm not sure how the destructuring happens yet).

There are other smallish differences too, I could have used Perl's sprintf, which would have more closely aligned with Python's implicit formatter:

sub buildConnectionString {
    my($params) = @_;
    return join(";",map { sprintf "%s=%s", $_, $params->{$_} } keys %$params);
}

But either language is more than capable. With the overloading of curly braces, even with my 10+ years of Perl experience, it's still a bit fuzzy to my eyes where the break is between the end of the hash-table (which is a map) and the code-block for the map. It's not that I can't read that code, or read it quickly, the dual meaning of the curly braces means that I have to use grammatical cues rather than just syntactic ones.

This is less than a first impression mind you. I'm trying hard to stay out of the Turing Tar pit. I like the list comprehensions and I like that Mr. Pilgrim introduced them right away in the book. I'm looking forward to the rest of it.

Programmers tend to know this without questioning it and often without being able to describe why: you can't reverse engineer requirements from code. This idea seems to be irresistibly seductive to non-developers though.

Requirements are, at their heart, declarative. Code is imperative. Well I suppose that depends and I'll come back to this topic later. A program is one possible solution to the requirement, one possible implementation. It is not the requirement.

Requirements declare "clean the car". Code says "Get a bucket. Get the car wash soap. Get rags. Get the hose. Turn on the hose. Fill the bucket." and so on. It could also have said "Drive to the car wash". Of course those instructions aren't necessary if the car isn't dirty (but you can't tell that from the instructions). They also could have meant "Wash the dog" or "Make lots of bubbles". If you didn't already have it in your head that the intent was to wash a car you'd probably be lost. Worse, you'd be lucky to figure out what it meant.

And what are the chances that there is a bug in the code? That bug would leave you with an error in your requirement. What if the instructions in the code are working around limitations in the programming language? What about the OS? The network? The database? What if....what if the program is working around errors in the data, which were introduced by some other application? What if it's a legacy version of the program itself?

You can use code as a clue though, as a guide. If you know what the goal probably was you can use the code as a way to try to disprove your hunch.

You can't reverse engineer requirements from code - you'll never hit the spirit or the meaning of the original requirements. You can certainly use the existing code to produce requirements for a system that re-implements the code itself (including workarounds, bugs and all), but you'll never produce the intent or core need that caused the application to be created in the first place. Not from looking at the code alone.

So, what about the earlier supposition? When you use non-imperative approaches to implement requirements what you end up with is a declarative (or functional) statement of...the requirements. They are stated in a more formal manner certainly, but they will be a statement of the requirements nonetheless.

This a core reason DSLs and XML configurations are often good solutions. SQL is successful because it allows you to say what you want, not how to get it from some internal, vendor specific, database API.

We all have constants in our applications, sometimes we have
numeric values that are only used once and are clearer if they're left
as an expression (like the number of seconds in a day, well these
things are better off as constants in many cases, though I'm only
using it as an example).

(defun days->seconds (days)
  (* days (* 24 60 60)))

(format t "seconds in ~a days:~a~&" 1 (days->seconds 1))

(time (loop repeat 1000000
	    do (days->seconds 10)))
 => 2.093 sec.

In common lisp there is a reader macro you can use to have these
kinds of expressions executed at compile time - and thus use no CPU
time during your running application (or even within the compiled
executable):

(defun compile-time-days->seconds (days)
  (* days #.(* 24 60 60)))

(time (loop repeat 1000000
	    do (compile-time-days->seconds 10)))
 => 1.87s

Admittedly in this case it's not a worthwhile improvement in
performance - but these are the kinds of things many technologies
represent as build processes. When you're configuring a build to be
specialized for a locale, or particular production environment, you
either factor those parts of the application into a configuration
file, or you generate code (almost certainly with some tool set which is
not your programming language).

I took the "make the title of your presentation confrontational" advice and changed the title from "Introduction to Lisp" to "Why Won't Lisp Just Go Away?"

It went much more smoothly the second time around. I also got some good feedback from Rob DiMarco and JP Vossen (author of the Bash Cookbook). It has been difficult to come up with a 60-90 minute talk, keeping it short enough, while still talking up the strong points.

I often prefer the shell and Unix utilities to having to wait to load data into a relational database or MS Access (unless a lot of what I'm doing requires complex joins). It's often possible to not even have to transform the encoding of the files before analyzing them. There are a couple of recipes for doing SQL equivalents with the shell utilities. There are a bunch of them, these are a few that I just used this morning. Most of the time all it takes is a bit of imagination about how to create a simple data-flow by composing a small handful of ubiquitous Unix utilities.

All these examples will also work within the Cygwin environment for Windows, or at a Terminal in OS X (especially when combined with the additional software available via Fink or Mac Ports projects..

Just selecting the count of records from an input file is one of the easiest things to accomplish (if your file is already line-oriented). The wc, or word count utility can do this easily. By default it counts characters, words and lines. With '-l' it will emit only the count of lines.

user@host:~/data$ wc -l table.tab
10

If you want to ignore the header, start with the second line (see the next example for a more thorough explanation):

user@host:~/data$ tail -n +2 | table.tab
9

For getting a distinct count of values in a column :

user@host:~/data$ cut -f1 table.tab | tail -n +2 | sort | uniq -c

The first part cut is a utility that allows you to take particular columns from a tab-delimited file, or character ranges from a fixed-width file. cut also allows you to specify the delimiter - but be warned that the commonly encountered CSV format requires more complexity in parsing than just using a comma as a delimiter. So this takes the first column out of the input file.

The next part of that is the tail command. tail is a command that outputs the end or 'tail' of a file. The '-n' option says what line number to start at (counted from the end of the file) - in this case the '+' tells tail to start at the second line from the beginning. This effectively tosses out the header line.

Next the values themselves are sorted. This is necessary for the uniq command, which will only collapse or count duplicate lines when they are adjacent.

Finally we reduce duplicate lines with uniq. The '-c' tells it to emit the count of duplicates when collapsing them.

Dealing with varoius file archive types

I often work with files in zip archives and tar (unix tape archive) archives, sometimes with additional compression applied to them (.Z, unix compress; .gz, gzip; and .bz2 bzip). It is possible to work with these files without having to unarchive or decompress them permanently if all you need is a simple count of lines or to only process them once.

Pulling a file from a Zip Archive

To pull one or more files from within a zip archive, and send them to another command (as part of a pipeline):

user@host:~/data$ unzip -l archive.zip
Archive: archive.zip
  Length    Date   Time   Name
 --------   ----   ----   ----
      34  04-28-08 11:01  table1.tab
      56  04-28-08 11:01  table1.tab
user@host:~/data$ unzip -c archive.zip table1.tab table2.tab | wc -l
36

That example uses the unzip command to pull 2 files out and send them to standard output - to either the screen or the next command in the pipeline. In this case that is wc to get the combined record count for the two files. We don't have to worry about cleaning up the two files when we're done either.

unzip -l lists the files in a zip archive. If we left off the '-c' (and the '| wc -l') unzip would have extracted just those two files from the archive (in case there were more and you only wanted a small handful).

Dealing with various file encodings

The first barrier to using most of these readily available utilities is often the file formats themselves. The utilities are line-oriented for the records and tab-oriented for the fields. So the first step is often figuring out how to even get your data into a tab-delimited format.

There is more to that than I have time to write right now. I'll work at following up with examples for another posting.

CLOS and slot (member) lookup recently came across c.l.l.

;; some reflection in clos

(defclass test-class
  ()
  ((s1 :reader :slot1
       :writer :set-slot1)
   (s2 :reader :slot2
       :writer :set-slot2)
   (s3 :reader :third-slot
       :writer :update-three)))


(defvar x nil)
(setf x (make-instance 'test-class))

(use-package :clos)

(class-direct-slots (class-of x))
;; =< 
;; (#<standard-direct-slot-definition s1="S1" #x19f471c9="#x19F471C9">
;;  #<standard-direct-slot-definition s2="S2" #x19f471f5="#x19F471F5">
;;  #<standard-direct-slot-definition s3="S3" #x19f47221="#x19F47221">)


(class-direct-superclasses (class-of x))

;; => 
;; (#<standard-class standard-object="STANDARD-OBJECT">)

(mapcar #'slot-definition-readers (class-direct-slots (class-of x)))
;; => ((:SLOT1) (:SLOT2) (:THIRD-SLOT))

(mapcar #'slot-definition-writers (class-direct-slots (class-of x)))
;; => ((:SET-SLOT1) (:SET-SLOT2) (:UPDATE-THREE))

Jason Stelzer just turned me on to ERC, an IRC mode for Emacs. It even just works with Windows, and comes with recent versions of Emacs (as of April 2008).

There are even easy ways to automatically start a session and connect to a channel - wrapping that up helped make it more automatic:

(defun krb-start-erc ()
  (interactive)
  (erc-open
   "irc-server-name-or-ip"
   6667
   "your-username"
   "your-full-name"
   t ;; connect
   "your-passwd")
  (erc-join-channel "datapump"))

It took too long for it to really click so while I'm thinking about this again I'm writing it down. There are good reasons why you should avoid using symbols of the form 'foo in preference to :foo. The main semantic difference is that the one preceded with a single quote is tied to the package where it occurrs, while the one preceded by the colon is placed within the keyword package.

What this means to you and your code may vary. One immediate reason to use keyword symbols (the ones that start with a colon) is that they are the same everywhere - they are equal (eq even). This means that they're shared - if you take symbols as arguments, or return symbols as values, then the keyword symbols will be easier to use. You won't have to export them from your package for them to be accessible (except in very rare, unhygenic, cases, eg: aif).

CL-USER> (defpackage :foo                                                                                                    
           (:use :common-lisp)                                                                                                        
           (:export :qux))
#<PACKAGE "FOO">
CL-USER> (in-package :foo)
#<PACKAGE "FOO">
FOO> (defun qux ()                                                                                                           
       'bar)
QUX
FOO> (equal 'bar (qux))
T
FOO> (in-package :cl-user)
#<PACKAGE "COMMON-LISP">
CL-USER> (equal 'bar (foo:qux))
NIL
CL-USER> 

That last one there was somehow confusing to me for a long time. Using keyword symbols solves that issue neatly:

CL-USER> (defpackage :foo                                                                                                         
  (:use :common-lisp)                                                                                                        
  (:export :qux))
#<PACKAGE "FOO">
CL-USER> (in-package :foo)
#<PACKAGE "FOO">
FOO> (defun qux ()                                                                                                           
  :bar)
STYLE-WARNING: redefining QUX in DEFUN                                                                                       
QUX
FOO> (equal :bar (qux))
T
FOO> (in-package :cl-user)
#<PACKAGE "COMMON-LISP">
CL-USER> (equal :bar (foo:qux))
T
CL-USER> 

The other reason to use them is that they're not just interned for the package they were defined in, but all keyword symbols are interned in the keyword package - saving memory in your running instance.

This point was lost on me until I started using packages seriously. I had no context for understanding it until I started using packages to organize my code.

In general you should probably be using keyword symbols as your default.

Someone asked for an example so I dug up my jspwiki tool. Here is the guts of the parser:

sub makeParser {
  my($data) = @_;
  my $pos = 0;
  my $setData = sub { $data = $_[0]; $pos = 0; };
  my $start   = sub { $pos = 0 };
  my $fwd     = sub { return -1 if $pos == -1; $pos += $_[0]; $pos = -1 if $pos >= length($data); $pos };
  my $bck     = sub { return -1 if $pos == -1; $pos -= $_[0]; $pos = -1 if $pos < 0;              $pos };
  my $bckTo   = sub { return -1 if $pos == -1; $pos = rindex $data, $_[0], $pos; };
  my $fwdTo   = sub { return -1 if $pos == -1; $pos =  index $data, $_[0], $pos; };
  my $fwdPast = sub {
    return $pos if $pos == -1;
    $pos = index $data, $_[0], $pos;
    return $pos if $pos == -1;
    $pos += length($_[0]);
    $pos >= length($data) ? $pos = -1 : $pos;
  };
  my $btwn = sub {
    return -1 if $pos == -1;
    my $s = $fwdPast->($_[0]);
    return undef if $s == -1;
    my $e = $fwdTo->($_[1]);
    return undef if $e == -1;
    my $item = substr $data, $s, $e - $s;
    return $item;
  };

  my $all = sub {
    my @all;
    while (-1 != $pos) {
      my $item = $btwn->(@_);
      last unless $item;
      push @all, $item;
    }
    return @all;
  };

  return ($setData,$start,$fwd,$bck,$fwdTo,$fwdPast,$bckTo,$btwn,$all);
}

and here is how it gets used:

sub getPageInfo {
  my($topic) = @_;
  my $data = $UserAgent->get("$BaseURL/PageInfo.jsp?page=$topic")->content;
  print "$data\n";
  my($setData,$start,$fwd,$bck,$fwdTo,$fwdPast,$bckTo,$btwn,$all) = makeParser($data);
  my $table = $btwn->('Version','</table>');

  ($setData,$start,$fwd,$bck,$fwdTo,$fwdPast,$bckTo,$btwn,$all) = makeParser($table);
  print join("\t",qw(Version Date Author Size Changes from Previous)),"\n";
  dumpRow($_) for $all->('<tr>','</tr>');
}

sub dumpRow {
  my($row) = @_;
  my($setData,$start,$fwd,$bck,$fwdTo,$fwdPast,$bckTo,$btwn,$all) = makeParser($row);
    print join("\t",map { simpleStrip($_) } $all->('<td>','</td>')),"\n";
}

This is just a code example - I had a new mailing list created at work and needed a large-ish list of people to get onto it. To save a bit of effort (admittedly a small amount) I scripted it.

; (require 'asdf-install)
; (asdf-install:install :drakma)

(require :drakma)
(use-package :drakma)

;; (http-request "http://mailman/mailman/listinfo/code-reviews")

;; <FORM Method=POST ACTION=\"http://mailman/mailman/subscribe/code-reviews\">
;; <INPUT type=\"Text\" name=\"email\" size=\"30\" value=\"\">
;; <INPUT type=\"Text\" name=\"fullname\" size=\"30\" value=\"\">
;; <INPUT type=\"Password\" name=\"pw\" size=\"15\">
;; <INPUT type=\"Password\" name=\"pw-conf\" size=\"15\">
;; <input type=radio name=\"digest\" value=\"0\" CHECKED> No
;; <INPUT type=\"Submit\" name=\"email-button\" value=\"Subscribe\">

(defun subscribe-user-to-code-reviews (email full-name pass)
  (drakma:http-request "http://mailman/mailman/subscribe/code-reviews"
                       :method :post
                       :parameters
                       `(("email"        . ,email)
                         ("fullname"     . ,full-name)
                         ("pw"           . ,pass)
                         ("pw-conf"      . ,pass)
                         ("digest"       . "0")
                         ("email-button" . "Subscribe"))))

; (subscribe-user-to-code-reviews "kburton@some-domain.com" "Kyle Burton" "some-password")

;; I went into outlook, opened the shared public contact list, did
;; CTRL-A, CTRL-C, went to excel and pasted, then saved as addrs.csv, then
;; do a bit of vi-magic to format the lines as expected below
(defun get-lines ()
  (with-open-file (in "/home/kburton/foo.txt" :direction :input)
    (loop for line = (read-line in nil nil)  then (read-line in nil nil)
       while line
       collect line)))

; (get-lines)

(require :cl-ppcre)
(use-package :cl-ppcre)

(defun split-line (line)
  (multiple-value-bind
        (string matches)
      (cl-ppcre:scan-to-strings "\"([^\"]+)\".*E-mail: (.+)$" line)
    (list (aref matches 0)
          (aref matches 1))))

;(split-line "\"Smith, John\" E-mail: jsmith@some-domain.com")

(loop for line in (get-lines)
     while line
     do
     (destructuring-bind
           (name email)
         (split-line line)
       (format t "name:~a email:~a~&" name email)
       (subscribe-user-to-code-reviews email "" "")))

Kudos to you Josh [Crean]. He stepped up and gave a tech-talk today at work on using unit testing and Devel::Cover. Not only did he give the talk, but he did it as a live interactive session - creating a module and its test, fielding questions and taking input from the other developers.

Actually he followed test driven development. This was based on comments by the audience -- he switched tack during the session.

Josh responded well to the "should we shoot for 100% coverage", and even showed an example (by coding it up as part of the live performance) where unit tests can drive software to 100% coverage and still contain bugs (100% coverage based on unit tests doesn't prove the code is correct in any way).

If you haven't checked out Test::Unit or Devel::Cover on CPAN, you should take a look. They can really improve the software you're developing.

Something interesting is going on that is a rare event: large tech firms are looking to merge. Microsoft has offered to merge (buy) Yahoo. This appears to be in an attempt to strengthen its on-line business units.

Some bloggers are taking this as Microsoft effectively admitting that they can't catch up in search or on-line advertising (not necessarily technologically, but definitely with respect to market share).

• Mark Cuban: Why Yahoo should say Yes to MicroSoft
• Yahoo may consider Google alliance, source says
• Yahoo! and the future of the Internet
• Google Offers to Help Yahoo Fight Off Microsoft

A lot of people have a lot to say...regardless of all the ideas that are flouted, the effects will ripple out for a long time. If MS succeeds, it will cause issues for Yahoo's current employees (there is rumor that many don't want to work for MS), if Google steps in and somehow scuttles the deal, it may be seen as some kind of evidence of weakness in MS and strength in Google.

Regardless, Microsoft seems to have some serious issues to work out - it seems to be in the process of finding itself again. How are they going to brand their on-line presence after this kind of merger? What are they going to do with Yahoo from a technology perspective? Yahoo is definitely not an MS shop (unix, PHP, Java). I wonder about this in context of what happened with the Hotmail acquisition of old...

I particularly like Scheme's let loop form:

(let loop ((x 1) (y 2))
     (write "x=") (write x)
     (write ", y=") (write y)
     (newline)
     (cond ((= x y)
            #t)
           (else
            (loop (+ 1 x) y)))) 

It allows you to define a locally scoped recursive function, with arguments and initial values, that is immediately called. It is clean and private - the name loop only exists within the let declaration - it is not available in any other scope.

I wanted the same form for programming in CL. There are two unfortunate things about this, the first is that loop is already defined (a public symbol in the CL-USER package). Although this is analogous to a reserved word in many programming languages, I could 'steal' the meaning of loop for just this scope, I just choose not to use the symbol loop when using this macro. The other unfortunate thing is that you can't 'extend' the let form (at least I don't know if it supports the same kind of run-time extension that setf supports). Regardless, if I chose a sensible name, it can be done:

(defmacro llet (name bindings &body body)
  (let ((args (mapcar #'first bindings))
        (initial-values (mapcar #'second bindings)))
  `(labels ((,name ,args
              ,@body))
     (,name ,@initial-values))))

(macroexpand-1
 '(llet lp ((x 1) (y 2))
   (format t "x:~a y:~a~&" x y)
   (cond ((= x y)
          t)
         (t 
          (lp (1+ x) y)))))

(llet lp ((x 1) (y 2))
   (format t "x:~a y:~a~&" x y)
   (cond ((= x y)
          t)
         (t 
          (lp (1+ x) y))))  

(llet recur ((x 1) (y 2))
  (format t "x:~a y:~a~&" x y)
  (cond ((= x y)
         t)
        (t
         (recur (1+ x) y))))

Not exactly the same, but just as useful and clean.