Attendee Statistics – a breakdown of the programming languages and OS of choice, as well as a geographic breakdown of where attendees came from.

Funniest Comment – someone’s IM status was set to “Developing a speech impediment…”

Presentations

• Setting up a Lisp Development Environment – this actually didn’t end up being much of a presentation, since the setup documents for Linux, OSX, and Windows ended up being so thorough that most people didn’t need to troubleshoot.
• Lisp Basics and Idioms (by Peter Christensen) – my intro talk that covered the history, concepts, and paradigms of Lisp. The goal was to give a big picture and proper mindset for development in Lisp.
  • HTML version of presentation slides (with links, extra resources, etc)
• Macros (by Craig Luddington and Eli Naeher) – an interactive talk on macros, showing basics of macro development, macro examination in SLIME, and a survey of some of the built-in macros of Common Lisp.
• Chat Server Development Demo (by John Quigley) – John started with a quiz-show style review where he tested two unwitting volunteers on their understanding of Lisps execution and development model. After that, he demoed a chat server that he wrote in about 250 lines of Lisp. Due to technical difficulties and time constraints, he wasn’t able to do the live updates, but we were proud to have several minutes of open chat on the server where no one cursed (I think the worst comment was “turd”). John has promised a demo of it at one of our meetings.

Book Raffle Winners

Congratulations to Luke Orland, Janet Kirsch, and (should have written down the third name) who won the following books in our registration raffle.

Gift-bag DVDs

Grant Rettke took the initiative to put together a “gift bag” DVD full of resources for people looking to learn more about Lisp development. The complete list is very long, but here is a summary:

• Electronic versions of books like OnLisp, SICP, etc
• Screencasts and movies like those from the SICP lectures, LispCast, the SLIME movie, etc
• Tons of documents like my SLIME cheat sheet, intro documents for Scheme and Lisp programming, some background and historical documents, etc

We’re looking to make an updated version of this DVD, including the materials from the workshop. Please let me know if you’d be interested one – if there is a lot of interest, we might make another batch and mail them out for a small fee.

After-Party

After the workshop, a dozen or so people walked down to Elephant & Castle Pub and Restaurant. I didn’t go since I had a house full of beautiful women waiting for me (my wife and daughters .

Sponsors

Special thanks to Kevin Taylor of Obtiva for sponsoring the food, drinks, gift DVDs, and the Practical Common Lisp prize book! Obtiva does on-site or outsourced development, and provides training in leading edge technologies.

If you want to look at the .ppt, you can download it here, but it’s pretty bare (or ugly, depending on how charitable you are), it doesn’t have as much info as the version below (no links, fewer references), and it is missing all of the good verbal ad-libbing I did when presenting. But hey, I’m not complaining if you want to see it!

***Lisp Basics and Idioms***

Lisp Is Old

• 1958: John McCarthy writes an algebraic list processing language for AI work
  • Original Paper: RECURSIVE FUNCTIONS OF SYMBOLIC EXPRESSIONS AND THEIR COMPUTATION BY MACHINE (Part I)
• McCarthy’s grad student wrote an interpreter for it
• Strongly tied to AI research during the 70s and 80s
  • Evolution of Lisp (pdf)
• Fell from prominence during the AI Winter

Lisp Is New

• Paul Graham’s essays – Beating the Averages, Lisp in Web-Based Applications
• Eric Raymond – “”LISP is worth learning for … the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot.“
  • This and lots more Lisp quotes
• Me – Lisp: The Good Old Days Will Never Come Back – Let’s Welcom a Bright Future
• Recent development of open source versions

Lisp Is A Family of Languages

• Common Lisp: ANSI Standard written in the 80s caused languages to coalesce, then implementations to flourish
  • Common Lisp Implementations: A Survey
• Scheme: A conceptually cleaner variant with a smaller specification
• Proprietary: LispWorks, Allegro
• Open Source: SBCL, CLisp
• Others: compile to C, run on JVM, etc

Lisp Is Functional, But Not Strictly

• Functional is the most natural to write
• Can make sequential blocks, either explicitly or in constructs
• Can make and change values if needed
• Can build and incorporate new paradigms as necessary, i.e. CLOS
• Lisp is strongly typed, dynamic typed

Lisp Has Lots of Parentheses

• “Lisp has all the visual appeal of oatmeal with fingernail clippings mixed in.” -Larry Wall
• Used to group expressions
• Makes syntax simple and consistent
• Most forms are (function args*)

But the Parentheses Aren’t a Big Deal

• “Parentheses? What parentheses? I haven’t noticed any parentheses since my first month of Lisp programming. I like to ask people who complain about parentheses in Lisp if they are bothered by all the spaces between words in a newspaper” – Ken Tilton
• Editors indent automatically
• Emacs commands to balance and close parens
• Paredit (Emacs library) lets you manipulate sexps directly

Lisp Uses Symbols

• Like variables but better
• Like pointers but less dangerous
• Assign a name to a value
• Values can be lots of things – numbers, strings, functions, lists, other data structures

Lisp Has First Class Functions

• Easy to define
  • (defun hello-world () (format t “hello, world”))
• Can be passed as parameters
• Can be returned as values from other functions
• Anonymous functions too!

Lisp Has Flexible Parameters

• Parameters can be optional, with defaults
  • (defun foo (a &optional b) (list a b))
  • (defun foo2 (a &optional (b 10)) (list a b))
• Parameter lists can be variable length
  • (defun + (&rest numbers) …)
• Keyword parameters
  • (defun foo3 (&key a b) …)

Lisp Uses Pairs

• Lists are chains of pairs
• 
• Can make other trees, etc as well
• 
  • Beyond Lists: Other Uses for Cons Cells

Lisp Uses Lists

• “It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures.” – Alan J. Perlis
• Tons of functions for manipulating lists
  • They Call It LISP For A Reason: List Processing
• Useful for recursive definitions
• Lists aren’t perfect so…

Lisp Has More Than Just Lists

• Collections
• Vectors – fixed size sequences
• Arrays – can be multidimensional, resizable
• Sequence functions on collections – COUNT, FIND, POSITION, REMOVE, SUBSTITUTE, etc
• This is one place where syntax would help
• (aref a 5) instead of a[5]

Lisp Does Lots More

• File and File I/O
• Advanced object system using generic functions and message passing
• Text formatting
• Fancy iteration constructs
• Conditions and restarts
• Libraries for other things

Lisp Has Lots of Free Online Resources

• Common Lisp: First Contact
• A Gentle Introduction to Symbolic Computation (buy dead tree copy)
  
• Structure and Interpretation of Computer Programs (buy dead tree copy)
  
• Practical Common Lisp (buy dead tree copy)
• OnLisp (buy dead tree copy)

We’re blogging live from the Chicago Lisp User Group’s Intro to Lisp Workshop, and (now that my presentation is done – whew!) here are some statistics on the attendees, based on our ghetto paper signin forms.

Total People: 41. Only 5 were involved in planning or presenting, and only 10 had ever been to one of our meetings.

Total Registration Forms: 25 31. This is the baseline for all of the statistics below (except How Did You Hear?) and doesn’t include Chicago Lisp members. 22 of them wanted to receive email announcements of future meetings.

Geographic Distribution:

Within Chicago – 68%
Illinois (outside Chicago) – 13%
Out of State – 19% (Madison and LaCrosse, Wisconsin, Omaha, Nebraska, and Columbus, Ohio)
People driving over 100 miles – 7
Furthest Travelers: Blaine and Scott from Omaha – 468 miles!

% Gmail Addresses: 45%

Primary Languages (% of registrants) – people could specify more than one

Java – 48%
Ruby – 39%
Python – 29%
C++ – 26%
C – 26%
Javascript – 16%
Perl – 10%
C# – 10%
Lisp – 10%
Obj-C – 6%
PHP – 6%
Bash – 3%
Erlang – 3%
VB – 3%
Fortran – 3%
Groovy – 3%
SmallTalk – 3%

Primary Operating System (% of registrants) – again, people could specify more than one

Linux – 71%
OSX – 48%
Windows – 13%
Solaris – 3%

How Did You Hear About The Workshop? (% of those who answered) – one answer, but I forgot to write it on the form so only 14 answered it.

Chicago Linux User Group – 29%
Chicago Python User Group – 14%
Chicago Ruby User Group – 29%
Other – 36%

I’ll put up Here’s an HTML version of my slideshow “Lisp Basics and Idioms” soon. I’m not sure what to do about the Macros presentation since it’s more in depth and was very interactive on screen (and we didn’t screen capture it). I video recorded the presentations but it’ll take me a while to get them off my camcorder and edit and process them. Keep your eyes here for more goodness.

The nice thing is that swapping out Common Lisp implementations within an Emacs/SLIME setup is easy, so maybe 3/4 of this guide is identical to the CLISP guide. I’ll put a disclaimer at the beginning of each section saying whether there’s anything new or whether you can skip it.

0. Files to Download [DIFF: The only difference is the link to the SBCL installer instead of the CLisp installer]

If you want to get started on downloading the setup files, here are the links:

• 7-zip (download v4.57 – 840K) – for unpacking .tar and .tar.gz files commonly used in *nix.
• Emacs (download v22.2 – 37MB)
• SBCL (download v1.0.13 – 9.8 MB)
• SLIME (download CVS snapshot – 700K) – apparently the SLIME 2.0 release is ancient and not worth using

1. Setup Directories [NO DIFF: skip if you've completed the CLisp guide]

Windows XP loves extremely long pathnames like C:\Documents and Settings\Username\Application Data. This is okay if for GUI-driven apps, but in Emacs, you’re not clicking, you’re typing, and you want short path names. Also, much (most?) of the open source Common Lisp tools are developed on *nix, so there’s less impedance mismatch when using stuff off the net if you have a *nix-ish folder structure.

Start with a root folder. In the pathnames in the rest of this guide, I’ll refer to it as [HOME]. I used C:\home\ to match the *nix convention of having user files be in /home/username/. You also need a username directory – I called mine peter and I’ll refer to it as [USR]. So in my case, [HOME]/[USR] would be C:\home\peter\.

Emacs NOTE #1: One important point about filenames in Emacs is that they CAN be entered with ‘/’, but if you prefer to use ‘\’, you have to escape it with another back slash, so in Emacs buffers and files, you would enter “C:/home/” or “C:\\home\\” but never “C:\home\”. The trailing slash is also important because it indicates that it’s a directory. Now that you have chosen your [ROOT] and [USR] values, these are the folders you should setup:

• [HOME]\[USR]\
• [HOME]\[USR]\site\
• [HOME]\[USR]\docs\
• [HOME]\[USR]\lisp\
• [HOME]\[USR]\info\
• [HOME]\bin\

2. Setup Emacs [NO DIFF: skip if you've completed the CLisp guide]

Emacs does not need to be “installed” like most Windows apps – it just runs from its directory. Extract it to [HOME]\bin\. I changed the folder name from emacs-22.2 to just emacs, so my path was c:\home\bin\emacs\. You run emacs by running the file [HOME]\bin\emacs\bin\runemacs.exe.

Emacs settings are stored in a configuration file called “.emacs”. On Windows, the default working folder and .emacs location is C:\Documents and Settings\Username\Application Data, but that’s too painful to type and it’s a hidden folder so it’s not even easy to get through with the GUI. To have Emacs work in a different folder, create a file called site-start.el in the emacs\site-lisp folder. In that folder, put the following line (but change the path to match yours):

(setenv “HOME” “[HOME]/[USR]/”)

(Thanks Nathaniel! This was probably the biggest annoyance of mine that made me put off finishing setup for so long.)

Emacs NOTE #2: Emacs has lots (and lots and lots) of keyboard shortcuts, many more than there are letters in the alphabet. Many of them require multiple keys or a sequence of keys called a “chord”. The two modifier keys used are Control and Alt (also called Meta). The common way to write chords is to use C- and M- for Control and Meta, so to run the command to close Emacs, you hold down Control and X, then let go, then hold down Control and C. This is written as C-x C-c. Sometimes a chord is followed by another letter or the name of a command. For instance, to undo, you hold Control and x, then let go and hit u. This is written as C-x u. Dashes mean press at the same time, space means let go. Easy! I made a cheat sheet for common commands in Emacs and SLIME.

Now it’s time to create your .emacs file. Run emacs and hit C-x C-f. This is the find command, which is used to create or open a file. At the prompt “Find file: “, type “~/.emacs” (without quotes). Right now just put a ; (that’s the comment marker in Emacs Lisp files) and save it by hitting C-x C-s. There’s a world of stuff you can put in a .emacs file, but that’s too much to bite off now.

3. Install SBCL [DIFF: This section is completely different]

Although the Windows port of SBCL is still experimental, there is a Windows installer (.msi) file for v1.0.13 (highest version as of now is v1.0.17). Just run the installer, and install it to the directory:

[HOME]\bin\sbcl-1013\

Then just finish the install wizard. But you’re not finished yet.

Robert Zubek wrote a post about 2 months ago about how to setup SBCL/Emacs/SLIME on Vista, but it doesn’t work exactly right on Windows XP. If you use the .emacs settings from his post, you get this error when you start SLIME (instead of using the .emacs settings in step 4):

fatal error encountered in SBCL pid XXXX:

can’t find core file at /user/local/lib/sbcl//sbcl.core

Process inferior-lisp exited abnormally with code 1

If you use the settings in step 4, you’ll get a different error message:

Searching for program: no such file or directory, sbcl

If you SBCL looks in the environment variable PATH to find the executable and core file. The default directories are *nixy, so it won’t find your sbcl directory on accident. But why should it look for the directory if you entered it into the install wizard?

Apparently Windows XP doesn’t update system environment variables until the system reboots. So right after you install SBCL, you have the user environment variables PATH and SBCL_Home but SBCL looks in the system variables. I couldn’t find out a way to fix that without rebooting, but the good news is that a reboot solves the problem.

So reboot your computer now.

4. Setup SLIME [DIFF: This section has some differences - links and .emacs setup]

Apparently the SLIME 2.0 is very old; several people recommend ignoring it and going straight to the CVS snapshot, so that’s what I linked to above.

Extract the SLIME folder to [HOME]\bin\emacs\site-lisp. (Here’s a tip about putting emacs code in site-lisp).

Now in Emacs, open your .emacs file (C-x C-f, ~/.emacs) and enter the following (general SLIME instructions, SBCL specific setup), changing your pathnames as usual. The good news is that because SBCL looks in the environment variables, you don’t need any of the command line parameters in the inferior-lisp-program variable:

(setq inferior-lisp-program “sbcl”)
(add-to-list ‘load-path “[HOME]/bin/emacs/site-lisp/slime/”)
(require ’slime)
(slime-setup)

Save the .emacs file (C-x C-s), then run the eval-buffer command (M-x eval-buffer). This will run the code that you just entered and tell Emacs how to run SLIME.

Now, you start slime with M-x slime and you’re ready to go!

NOTE: This is a basic SBCL setup – I’ve found some more advanced setup links that I’ll write guides for later:

• Setup ASDF-Install/SBCL on Windows
• Running SBCL on Windows – this is again for Vista, with the newest (v1.0.16 and v1.0.17) versions of SBCL. It also includes configuring shell commands, etc.

Additional comments at comp.lang.lisp.

<thankstosponsors>

CashNetUSA is looking for Ruby developers, or more accurately, great developers who know Ruby. They’re hiring at all levels of experience – check out their job listings. Thanks, CashNetUSA!

</thankstosponsors>

John Q. donated a copy of Programming Erlang to our first book raffle, which was won by Craig L. If anyone has a book they’d like to donate, please contact me so I put it in announcements for future meetings.

Intro to Lisp Workshop

There was some more discussion about the details of the Intro to Lisp Workshop on May 31. The most noteworthy decisions were:

• standardize on SBCL, SLIME, Emacs
• have a set of milestone files that people who can’t keep up with the presentations can download to get themselves caught up
• recommended screen capture softweare: xvdicap, vnc2swf

Future Meetings

We also planned presentation topics for future meetings:

• June: Kurt S. will present on implementing interpreters, and Steve G.’s presentation on Lisp languages on the JVM got bumped to June in the interest of time at May’s meeting
• July: Andrew W. will demo Open Genera, the operating system from Symbolics’ Lisp machines
• future: John Q. knows a guy who could presnet on programming language topics, I will (someday) present on Weblocks

Presentation: A Basic Object System Using Macros

The rest of the meeting was Grant R.’s presentation on how he wrote his own object system using closures in Scheme. Check out his presentation slides (here or here) and the code from his demos (here or here). The slides are supplemental to the discussion and the demo, so if you’re trying to get the message from just the slides, shame on you for not coming to the meeting. Grant gets extra style points for writing his slides in Scheme and displaying them using a slide program in DrScheme. There were a couple times he wanted to change his slides and he did so in code in the DrScheme IDE. Cool!

Grant is a big proponent of using “toy projects” to learn fundamental concepts. In this case, he wanted to understand objects and closures better, so he iterated through a couple versions of a simple object system implements using closures, including using hygenic and unhygenic macros. In the process, he got more experience with language features and concepts. His final system included methods and variables, encapsulation, message passing, lexical scope, and name collision detection. He approached it as a code generation problem – write the code you want, then abstract out the essence using macros and syntax extension.

The end of the presentation was cut off due to technological failure (projectors, gotta love them), but he had some great closing thoughts:

• toy projects are a great learning experience
• Lisp is a great vehicle for exploring ideas, which you can then use in other languages
• don’t become a language slave; embrace the best ideas from all languages
• put in the time and effort to improve your study habits
• Lips introduces powerful ideas that are hard to find in other languages

Check out his slides and demo code. They are nice, but like I said, the real value was in the discussion during the presentation. Grant has worked with Scheme but not Common Lisp, and several people (myself included) were the opposite. There were also people who knew both languages well and could explain some of the differences. For instance, there were two Scheme language features (lexical scoping and hygenic macros) that I knew of but didn’t understand well, but Matt, Kurt, and Andrew explained it in a way that finally made sense to me. I’m not the only one who learned from both the presentation and the discussion; there are some seriously smart people in this group and I can’t wait for the next meeting to participate in more stimulating discussions like this.

Info is an output format for the Texinfo typesetting syntax. Texinfo is used for writing documentation that can be output in multiple print and digital formats and is the official documentation format of the GNU project. Info files are strongly associated with Emacs – Emacs is the primary reader for Info files, but there is also a standalone reader. Manuals are organized into a tree of nodes, with a variety of ways to navigate between those nodes.

Info files can technically be written by hand, but it is much more common for them to be compiled from Texinfo. Many Linux/Unix distros come bundled with the TeX toolchain necessary to compile Texinfo, but Windows does not. The TeX/LaTex/Texinfo on Windows post is coming in the near future. For now, stick to precompiled .info files or go dive into TeX yourself.

Emacs ships with several Info manuals – they’re in the emacs/info folder. You can also create your own Info directory, add new manuals to the directory, and create your own manuals. This guide will walk you through the steps needed to get Emacs to find your info directory, add manuals in your directory to the main directory list, and use Info from within Emacs.

[NOTE: This guide assumes you're following the directory conventions I laid out in my previous post Installing CLISP, Emacs, and SLIME on Windows XP. It also gives you the baseline level of familiarity with Emacs to follow along here.]

1) Setup Emacs to recognize your info directory

You should already have an info directory. Mine is C:\home\peter\info, and from emacs the path is ~/info/. To make this the first directory Emacs looks in when compiling the directory, add this to your .emacs file (feel free to indent better than WordPress allows):

(require ‘info)
(setq Info-directory-list
(cons (expand-file-name “[HOME]/info”)
Info-default-directory-list))

2) Create a dir file in [HOME]/info/

When Emacs is looking in directories for info files, it only looks for a file called “dir” in each directory. This dir file is a special kind of Info file that points to the other Info files in the directory and lists and orders them. In order to make your own dir file, you first need a .info file to link to. I recommend the Structure and Interpretation of Computer Programs in Texinfo manual (download precompiled 400K sicp.info.gz file here). There is a whole syntax for defining nodes, but this is the bare minimum you need to get your manual into the directory.

First, start with the characters “^_”. That doesn’t actually work when you type it in directly, so you need to copy it from Emacs’ info/dir. I looked at that file in a hex editor and it had the value 1F (US – unit separator) – the ASCII values for ^_ are 5E 5F. I had to open the emacs/info/dir file and kill/yank it into my dir file. Kill/yank is Emacs’ version of cut/paste. Like all things Emacs, it’s similar, not exactly the same, and much more powerful. Here are the steps (free Emacs tutorial included):

1. Open the Emacs info dir file with: C-x C-f [HOME]/bin/emacs/info/dir
2. Select the ^_ characters
   1. Put the cursor at the beginning and set the beginning of the region to cut (C-SPC)
   2. Move down to the beginning of the next line and cut to the end of the region (C-W)
   3. Yank it back into the file with C-y
   4. Save the file with C-x C-s
3. Create your dir file with find file (C-x C-f) at ~/info/dir
4. Yank (paste) the text into the file with C-y

That should work, but there’s still more to add to the file. Next is the Tree info – at least your file and node names. This works for your personal dir file:

File: dir Node: Top This is the top of the INFO tree

You can put a header if you like (“My Info Manuals”), then on a new line, put:

* Menu:

After that, you can add links to your manuals. The format is:

* TITLE: (filename w/o .info). Summary

For the SICP manual, it would look like this:

* SICP: (sicp). Structure and Interpretation of Computer Programs

You can put a footer after that to separate the manuals in your directory from those in others. The final dir file ends up looking something like this:

^_
File: dir Node: Top This is the top of the INFO tree

Peter’s Info Directory
**********************

* Menu:

* SICP: (sicp). Structure and Interpretation of Computer Programs

—- User’s ‘dir’ ends here —-

[Now that you did all that, feel free to download my dir file and change the labels as you see fit. ]

3) Using Info

Info has a similar structure to HTML, where there can be links within and between nodes, but there’s also an explicit tree structure with its own structured navigation. Here’s a pretty complete set of commands, with shorter descriptions and better grouping than the Info help shows.

Basics
C-h i – start Info
q – quit info
? – info commands
SPC – returns from commands screen

Node Navigation
p, n – previous/next node in subtree
[, ] – previous/next node in tree traversal
l, r – back/forward in node nagivation history
u – Move up
space – pagedown or next node
del – pageup or previous node
b – go to beginning of node

Links
M-TAB/TAB – previous/next cross-reference or menu item
m – type name of menu item and go to that node

Jump
d – return to Info directory
t – return to file root
L – go to menu of visited nodes
T – go to table of contents of the current Info file

Search
s – regex search, move to node where next match is found
S – regex search, case sensitive
M-x Info-search-next – repeat previous regex search
i – search for and jump to index topic
, – repeat previous i search
g – move to node specified by name – to filename by searching for (FILENAME)NODENAME
1..9 – jump to 1st-9th item in node’s menu
w – put name of current node into kill ring
M-n – clone Info buffer to new window

——————————-

That’s all for Info – it only takes 10 minutes to go through the Info on Info tutorial and it’s easy to use. This is just one of the many things that takes a couple hours to muscle through the setup and online docs, then it makes things so much easier EVERY SINGLE TIME you use it afterwards. My goal is to take these 2-3 hour research tasks and turn them into a 10 minutes guide. Hopefully by lowering the barriers to competence, more people will seek out and invest in learning the great tools out there that Windows developers tend to miss out on.

For instance, the Common Lisp Cookbook has a very thorough page on Setting Up an IDE with Emacs on Windows or Max OSX, but as far as I can tell, it’s from 2004 or earlier because it doesn’t mention SBCL or SLIME, two of the most popular pieces of CL development software today. Or when you run into a specific problem, it’s usually not too hard to find an answer, but it might not match the setup you’re using. That’s why I had to quit using Lispbox, because no one had any clue how it was configured, especially not on Windows. n00bs didn’t know the answers and the wizards had a traditional setup.

Here are some of the variables that contribute to the combinatorial explosion of configuration, in order or pain caused:

• Operating system: Linux (many flavors), Mac, Windows, Cygwin
• CL implementation: most common are SBCL, CMUCL, Allegro, LispWorks, CLISP
• CL implementation version (I ran into a problem here)
• SLIME version (stable 2.0 release or CVS snapshot)
• Emacs version (I didn’t run across any problems with this)
• I almost forgot, now there’s Cusp/Eclipse if you don’t want to use Emacs/SLIME, but right now Cusp is only tested on SBCL.

Maybe someday someone will try out all of those combinations and report, but for today, I did exactly one: Windows XP, CLISP 2.44, SLIME CVS, and Emacs 22.2 Why CLISP? After reading lots of internet, I came to the conclusion that (aside from the commercial CLs), CLISP is the best implementation for Windows users. The knocks against it are that it’s slow because it’s byte-code compiled, it doesn’t have threads, and on some points, it’s ideologically different from CL and other implementations.

Well, the performance isn’t a big concern for me (plus as I went to press, 2.45 was released with experimental JIT compilation), the threads also aren’t a big deal right now, and I think the differences will help me be aware of the considerations for writing portable code. Also regarding the SBCL windows port, it’s still considered experimental (currently v1.013 for Windows) but people are saying it’s stable and everything works except the threads. There’s even an msi installer for the Windows version. One of my next projects will be to dive into the SBCL documentation and mailing lists to get a better feel for it.

As far as the philosophy behind this (and future) setup guides, I want them to be a) thorough and b) instructive. Instructive? If you just want to take my word for everything, that’s fine, but I want you to know where I got my info from, so I’ve tried to include links to references for each step. On to the setup guide!

0. Files to Download

If you want to get started on downloading the setup files, here are the links:

• 7-zip (download v4.57 – 840K) – for unpacking .tar and .tar.gz files commonly used in *nix.
• Emacs (download v22.2 – 37MB)
• CLISP (download v2.44 – 4MB)
• SLIME (download CVS snapshot – 700K) – CLISP recently removed a function used in the 2.0 version of SLIME, but the SLIME CVS snapshot has that fixed

1. Setup Directories

Windows XP loves extremely long pathnames like C:\Documents and Settings\Username\Application Data. This is okay if for GUI-driven apps, but in Emacs, you’re not clicking, you’re typing, and you want short path names. Also, much (most?) of the open source Common Lisp tools are developed on *nix, so there’s less impedance mismatch when using stuff off the net if you have a *nix-ish folder structure.

Start with a root folder. In the pathnames in the rest of this guide, I’ll refer to it as [HOME]. I used C:\home\ to match the *nix convention of having user files be in /home/username/. You also need a username directory – I called mine peter and I’ll refer to it as [USR]. So in my case, [HOME]/[USR] would be C:\home\peter\.

Emacs NOTE #1: One important point about filenames in Emacs is that they CAN be entered with ‘/’, but if you prefer to use ‘\’, you have to escape it with another back slash, so in Emacs buffers and files, you would enter “C:/home/” or “C:\\home\\” but never “C:\home\”. The trailing slash is also important because it indicates that it’s a directory. Now that you have chosen your [ROOT] and [USR] values, these are the folders you should setup:

• [HOME]\[USR]\
• [HOME]\[USR]\site\
• [HOME]\[USR]\docs\
• [HOME]\[USR]\lisp\
• [HOME]\[USR]\info\
• [HOME]\bin\

2. Setup Emacs

Emacs does not need to be “installed” like most Windows apps – it just runs from its directory. Extract it to [HOME]\bin\. I changed the folder name from emacs-22.2 to just emacs, so my path was c:\home\bin\emacs\. You run emacs by running the file [HOME]\bin\emacs\bin\runemacs.exe.

Emacs settings are stored in a configuration file called “.emacs”. On Windows, the default working folder and .emacs location is C:\Documents and Settings\Username\Application Data, but that’s too painful to type and it’s a hidden folder so it’s not even easy to get through with the GUI. To have Emacs work in a different folder, create a file called site-start.el in the emacs\site-lisp folder. In that folder, put the following line (but change the path to match yours):

(setenv "HOME" "[HOME]/[USR]/")

(Thanks Nathaniel! This was probably the biggest annoyance of mine that made me put off finishing setup for so long.)

Emacs NOTE #2: Emacs has lots (and lots and lots) of keyboard shortcuts, many more than there are letters in the alphabet. Many of them require multiple keys or a sequence of keys called a “chord”. The two modifier keys used are Control and Alt (also called Meta). The common way to write chords is to use C- and M- for Control and Meta, so to run the command to close Emacs, you hold down Control and X, then let go, then hold down Control and C. This is written as C-x C-c. Sometimes a chord is followed by another letter or the name of a command. For instance, to undo, you hold Control and x, then let go and hit u. This is written as C-x u. Dashes mean press at the same time, space means let go. Easy! I made a cheat sheet for common commands in Emacs and SLIME.

Now it’s time to create your .emacs file. Run emacs and hit C-x C-f. This is the find command, which is used to create or open a file. At the prompt “Find file: “, type “~/.emacs” (without quotes). Right now just put a ; (that’s the comment marker in Emacs Lisp files) and save it by hitting C-x C-s. There’s a world of stuff you can put in a .emacs file, but that’s too much to bite off now.

3. Install CLISP

This is easy if you download the install package (that’s the one I linked to). Run the installer and choose [HOME]\bin\clisp\ as the install directory. That’s it!

4. Setup SLIME

CLISP changed recently (around version 2.44 – not sure exactly) and broke compatibility with the SLIME 2.0 release. This was fixed in development and the CVS snapshot works. If you try to use the 2.0 release, you’ll get an error that looks like this:

INTERN(“FRAME-UP-1″): #<PACKAGE SYSTEM> is locked

So use the CVS snapshot (which I linked to) and you should be fine.

Extract the SLIME folder to [HOME]\bin\emacs\site-lisp. (Here’s a tip about putting emacs code in site-lisp).

Now in Emacs, open your .emacs file (C-x C-f, ~/.emacs) and enter the following (general SLIME instructions, CLISP specific parameters), changing your pathnames as usual:

(setq inferior-lisp-program “[HOME]/bin/clisp/full/lisp.exe
-B [HOME]/bin/clisp/full
-M [HOME]/bin/clisp/full/lispinit.mem
-ansi -q”)
(add-to-list ‘load-path “[HOME]/bin/emacs/site-lisp/slime/”)
(require ’slime)
(slime-setup)

Save the .emacs file (C-x C-s), then run the eval-buffer command (M-x eval-buffer). This will run the code that you just entered and tell Emacs how to run SLIME.

Now, you start slime with M-x slime and you’re ready to go!

————————————–

I hope this works for you – I ran through it on another computer and it worked the first time, so if you use exactly these parts you should be OK. Please let me know if you run into problems so I can incorporate the fix into my doc. Many thanks to everyone who I linked to, since they did the coding, testing, and writeups that I used to get here. More resources to come – tell me what you’d like to see. If it’s something I was planning on doing anyway, I’ll move it up my queue.

The next guide will probably be setting up your built-in documentation (Hyperspec, etc).

Here are our attendees:

Peter Christensen
John Quigley
Craig Luddington
Matt Bone
Brendan Baldwin
Andrew Wolven
Bruce Burdick
Chad Slaughter
Kurt Stephens
Steve Githens
Alex Hemard

ITEMS OF BUSINESS:

Name – None of the name ideas got much support, so we’re sticking with Chicago Lisp until someone comes up with something awesomer.

Project – No one had any ideas for or time to work on a project as a group so that’s also waiting for an awesomer idea.

Server – John and Craig both have servers where they can host things but not allow remote access to. John has a basic homepage at http://www.chicaglisp.org and has a mailing list setup. There might be a wiki in the future. Meeting announcements and recaps will continue to be on Peter’s Chicago Lisp page and then cross posted to the two mailing lists and the chicagolisp.org site.

Next Meeting

WHEN: Friday, May 16th at 7pm.

WHERE: CashNetUSA offices. 200 W. Jackson Blvd, 14th floor, Chicago. Map.

WHAT: Lightning talks. The following people have signed up, more welcome (email Peter if interested or add a comment at Coordinatr)

• Grant Rattke – A simple object system using macros
• Steve Githens – Scripting a Java SOA system using Kawa and Clojure
• Dry runs from the people presenting at the Intro to Lisp Workshop

Intro to Lisp Workshop: We did some pre-planning and delegation. See details here.

Presentation on Combined Object-Lambda Architectures (COLAs):

The inagural presentation of our group was about the work done by the Viewpoints Research Institure (VPRI). The most recognizable name associated with this is Alan Kay, Mr. Invent the Future himself. John Quigley made an excellent slide deck (pdf) where he reviewed the paper “Making COLAs with Pepsi and Coke” (pdf) by Ian Piumarta and put into slightly more comprensible language.

This paper is for the Fundamental New Computer Technologies project at VPRI. The aim of the project is to create a complete computing system in 20,000 lines of code. This system would be everything from the hardware to the UI and include both design and implementation. Having such a compact system would be a useful exploration and learning tool, so every part of it can be inspected and manipulated. They’re currently 18 months into a 5 year project but they already have made intriguing progress.

John’s presentation was about the architecture of the self bootstrapping system. I can’t claim that I understood it all, or even most of it. I was able to keep up mostly because I had come across VPRI’s work on Jeff Moser’s blog earlier in the week so I was familiar with the overview. What I did sort of grasp boggled my mind and definintely but VPRI on my technical radar, if for no other reason than as a technical challenge to aspire to.

If you can understand everything in Piumarta’s paper (or even in John’s summary deck), you’re a whiz. If not, don’t feel bad. I would recommend reading the NSF proposal (pdf) and the first year progress report (pdf). They’re in more accessible, less technically deep language and they have pretty pictures.

Thanks John for setting the bar high right out of the gate!

WHEN: this Friday, April 18th at 7pm.

WHERE: 210 S. Clark St, 24th floor (map). Sign in at the front desk, take the elevator to the 24th floor. There is only one suite there and the door will be held open.

WHAT:

• John Quigley will be giving a presentation on continuations Alan Kay’s Fundamentals of New Computing Initiative (see Viewpoints Research Institute, their NSF proposal, and their one year progress report) (notes will be posted afterwards).
• Soliciting Lightning Talk topics for next meeting (5/16). Grant Rettke has already signed up for “A Simple Object System Using Macros”. 2-3 more would be nice.
• Some (short) planning for future meetings, Intro to Lisp workshop, etc
• Ideas for a project we could hack together

AFTER: Food and drinks. Possibly at Elephant & Castle Pub.

We had 7 people last month, let’s try for more!

If you’d like to hear about future meetings, please subscribe to the chicago-lisp mailing list or send me your email address and I’ll add you to the invite list at Coordinatr.com.

Two weeks ago (March 21st), we had our first meeting to bootstrap the new Chicago Lisp User Group.  We had 7 people show up for the initial meeting:

Craig Luddington
Eli Naeher
Victor Kryukov
John Quigley
Shaneal Manek
Dave Morrow
Peter Christensen

Items Covered:

Future meetings – We decided on monthly meetings, the third Friday of every month, 7pm.  The next meeting will be Friday, April 18th where John Q. will give a presentation on continuations.  The May meeting will have several lightning presentations – submissions welcome (please post a message on the Coordinatr event)!  All but one of the attendees live or work in the city of Chicago, so we decided that all meetings will be held in Chicago.

Meeting locations – The first meeting was held at Ambrosia Cafe (1963 N. Sheffield, Chicago, map: http://tinyurl.com/2koztz).  It was a nice place for a meeting but we’d like to find a place to meet with a projector, so presentations can be given and recorded.  Some proposed locations are the IIT Institute of Design (350 N. LaSalle St) and the Harold Washington Library (400 S. State St).  If anyone has an office or location they’d like to volunteer, please let me know.

Scope – We decided to keep the group and meeting open to the greater Lisp family – Common Lisp, Scheme, Arc, etc.  That will be the focus of the group but all are welcome to attend.  Some people expressed desire to start or adopt a project that we could work on as a group.

Name – Some people wanted a better name than “Chicago Lisp”, and who can blame them?  One nomination as “LispChics” (inspired by NYC’s Lispniks) but I thought it was false advertising (7 guys with laptops, Chics, ??).  The name is up in the air, nominations accepted.

Web Presence – John Q. owns the chicagolisp.org domain and Craig L. has a server he volunteered for use.  A project we develop could be hosted there, and I recommended a CLiki instance for group notes.  I’ve also setup a group on coordinatr.com that I’d like to try out for organizing meetings.  You should get an email soon.

The common-lisp.net chicago-lisp mailing list will still be used but only as a supplement.  The list is not great because of spam but there are a hundred or so subscribers still on the list that would have no other connection to the group.

Intro to Lisp Workshop – John Q. informed of a planned, all day workshop designed to introduce programmers to using Lisp – from installing and setting up an image to programming basics to advanced concepts.  It is planned for a Saturday in May (date TBD, location probably Institute of Design) and volunteers would be appreciated.

Coordinatr – I’ll be trying out a new site called Coordinatr.com to manage the meetings.  You can RSVP there, submit ideas for proposals, etc.  You should receive email inviting you to the first two meetings shortly after this email.  There is also a feed of new events created for this group here:  http://coordinatr.com/feeds/rss/vcwxbvdrepk2blkbtwctez .  You can get updates and reminders by email and/or SMS, but I think the RSS feed doesn’t get updated (the platform has only been out for a couple weeks).  Let me know how this works – I think it’ll be better than a zillion back and forth emails.

You can view the feed without registering at the site, but you need to register AND be invited to see the event website, RSVP, post messages, etc.  Good news is that you can invite new people to an existing event once you’ve registered.

Calendar:

Friday, April 18, 7pm: Chicago Lisp Meeting
Location TBD
Presentation on Continuations

Friday, May 16, 7pm: Chicago Lisp Meeting
Location TBD
Lightning presentations, accepting submissions

Some Saturday in May: Intro to Lisp Workshop
Location TBD (probably Institute of Design)
Getting started with Lisp, all-day event

Homework Items:

Name the Group!  Send submissions to Peter

Lightning Talk Proposals for May 16 meeting

Locations for future meetings – 3rd Friday of the month, 7pm, ~10 people, preferably with wireless access and a projector.  If you have a place, email Peter

Feedback on using Coordinator for managing events

Thanks,
Peter Christensen
DFGL (de facto group leader)