mqt

    - Allan Blomquist (Wii port)
    - Paul Hubans (QA and Production associate)
    - Maks Verver (Linux port)

    curl -s -L http://phobos.apple.com/version | grep Restore | grep '_3.'

    iPhone1,1_ = 2G

    iPhone1,2_ = 3G

    iPhone2,1_ = 3G S

    <link rel="prefetch" href="http://example.com">

    On-Topic: Anything that good hackers would find interesting. That includes more than
    hacking and startups. If you had to reduce it to a sentence, the answer might be:
    anything that gratifies one's intellectual curiosity.

    There are different strategies to create CL applications.  
    
    - save an executable image. This will mostly dump the Lisp system and
    when you start it up, you have mostly everything back. The size
    of the dumped image depends on the size of your Lisp system. SBCL
    is already large and does not have any special features to make
    it smaller. CLISP for example writes much smaller images than
    SBCL. Clozure CL is also smaller. Here also is important with how
    much debug information the original Lisp image was created. The
    saved image typically will include all that. Corman CL on Windows
    compresses the Lisp data to save space. 
    
    - deliver an application. That's for example what LispWorks and
    Allegro CL can do. They allow functionality and
    information (debug info, documentation strings, arglists, source
    locations, symbols, caches, ...) to be removed (for example by
    treeshaking, or by removing whole functionality groups). The size
    of the generated application will depend on what you leave out
    and which delivery level you are choosing. Stuff that might not
    be needed: compiler, debugger, disassembler, editor, inspector,
    REPL, ...
    
    - deliver a static application. I don't know which currently
    maintained CL implementation does that. There were several Common
    Lisp implementations that generate 'small' and static C code from
    Lisp. CLICC, Ibuki's CONS, WCL, Lisp-to-C, ThinLisp were in that
    league. They were used for application delivery, where the
    application might be really small and does not have any large
    runtime or development environment.
    
    There are also some other options. Probably ABCL could generate a
    JAR file that could be started with an installed JVM. Often Lisp
    compilers can compile code to native code compiled files (fasls)
    and even can append several fasls into one. Then one does need
    only to ship the fasl file, given that the user has the a Lisp
    installed that can load the fasl.