Kenny Tilton just wrote a great article that I think cuts through a lot of the clutter that gets spoken about Lisp. Among the great quotes in the article, he says:

“The first reason you should be using Lisp is a non-reason, an answer to an objection, a negation, a let-down: Lisp is just an ordinary programming language.”

and

“Lisp at one level of understanding is just a normal high level programming language. Those parentheses look quite different but constitute only a superficial difference from the conventional chicken scratch syntax of semi-colons, braces, full stops, and brackets. When a conventional programmer sits down to program Lisp, they feel quickly at home: Lisp is just another 3GL.”

“I feel terrible about this. I am supposed to be up on a soapbox preaching eternal salvation and ecstasies glorious and unknown”.

I couldn’t agree more. While I haven’t officially taken the Road to Lisp survey, I will say that I started out by reading Paul Graham’s essays, which sparked my interest but didn’t convince me to ask. Paul is an honest, straightforward, persuasive writer, but in a world where everything is overhyped and “The Greatest, Most Extremest X EVER!!!!!!” I looked for some more confirmation before taking him at his word. Well, I found it. Not in any specific place, but in the sum of a year of experience reading reviews, comments, history, blogs, and books, and doing some programming of my own. And the answer I came up was that Lisp is simply a great general purpose language. And since everyone else has the same wariness about any “Most Extremest EVER!!!!”, I think Kenny can close sum it up better:

“Lispers are accused of religious fanaticism and zealotry — nope, our enthusiasm is all about getting applications built faster with less pain.”

Amen.

Following up on my transcript/review of the UCW “Hello World” screencast, here is my review of Marco Barringer’s SLIME movie. (Description, 150MB .mov, Torrent, watch online). This screencast was more difficult to annotate because:

1. It was almost 3x as long (55 min vs. 20)
2. It covered more topics (Linux, Emacs, Lisp, SLIME)

I did find it much more interesting though because it showed off a lot of the cool features in those topics, whereas the UCW screencast was mostly just instructional. Also, I don’t know if I’ll ever use UCW for an app, but I’m already using the LELS stack and plan on using it for a long time to come.

(See what other people have said about it)

Looking back at my UCW reference, I think the format worked for that screencast because it was mostly just straight Lisp code. In the SLIME movie, the Lisp code is the least useful part – it’s just the vehicle for showing off the tools. So there’s a mix of Linux commands (unfortunately omitted because WordPress or Apache or somebody thinks they’re a security problem), Emacs key chords, Emacs Lisp code, and Common Lisp code. I’m leaving out most of the Common Lisp code for the morse code translator to focus on what’s more relevant. Also, I added links to documentation for the features shown. Hopefully this will make it easier to watch the movie and get straight to work on your own projects!

[Read more…]

I think one of the things that made Ruby on Rails so popular was the screencasts where you could write a blog site in 20 minutes, integrate with Flickr in 5 minutes, or setup database migrations in 20 minutes. It’s hard to overstate how mindblowing those were in 2005 (or whenever they came out). At that point, the only languages I had ever used were Pascal, C, C++ (all in school) and C#/.Net (in jobs). I was used to (and blind to) the big, industrial scale, industrial pain in the butt that those languages consist of. Ruby on Rails just seemed to dance, seemed so easy and flexible. I didn’t ever end up getting into RoR, but interest in it did start me on the language learning, abstraction seeking path I’m on today.

Lisp happens to have a number of similar screencasts. I’ve looked at a couple of them, both by Marco Barringer. I watched the first half of the SLIME movie and was blown away (I only watched the first half because 3:30am isn’t a great time to stay awake through a screencast). He was just throwing out tricks right and left: Linux tricks, emacs tricks, slime tricks, Lisp tricks. I kept rewinding and rewatching parts, like a bunch of Cub Scouts trying to figure out how a magician makes a handkerchief disappear. I have installed and played with emacs and SLIME, but I didn’t get the gist of what it could do. Everyone said it’s so powerful, and I believed them. They said it was extensible and reprogrammable, but I’m not ready to take on that. I tried looking at the documentation, but everything is presented so evenly that I couldn’t get a sense of where to start. I decided that the SLIME movie was too good of documentation to be stuck inside a non-search-indexable video format, so I re-downloaded it and started watching it, frequently pausing and taking meticulous notes on key chords, exact times that different things happen, and setup commands, with the intention that the lessons it contains could easily be referred to later. Well, I had to stop that because my download is corrupted, I only have the first 8 minutes, and right now the download link isn’t working. So I moved on to the next video (which was actually the first video), the UCW “Hello World” screencast (download 51MB .mov or torrent).

In this 20 minute video, Marco created a simple website using UCW, the UnCommon Web application framework (that Marco created). The focus was teaching how to write a simple site and what each of the commands and components means, so it was a little slower and had less “zing” than the RoR screencasts, which just demonstrated how quick it was to work with without waiting for you to figure out what’s going on. Also, since it was focused on the basics of UCW, it didn’t give a good feel for how powerful UCW actually is. I think it would be a great Part I in a series of screencasts showing the progression to use more and more of the power of the framework. Regardless, I have my notes anyway. I haven’t done any special formatting or cleaning up. I plan on doing this for more of the Lisp movies and I’ll wait until I’ve found a style I like, then go back and clean them up. The only thing special is that actual Lisp code is marked with “—” on the lines immediately above and below it. Here goes:

[Read more…]

As part of my year’s learning goals, I’ve started reading Peter Norvig’s Paradigms of Artificial Intelligence Programming. I’ve gotten through the first few chapters (introductions to Lisp and a small sample program), and so far it’s a great book. Now, since I’m a cover-to-cover kind of guy, I even read the introduction, and I’m sure glad I did. There’s a great money quote that I’ve never seen anyone reference that is so self-explanatory I’ll just shut up and quote it:

“There is a myth that Lisp (and Prolog) are ‘special-purpose’ languages, while languages like Pascal and C are ‘general purpose.’ Actually, just the reverse is true. Pascal and C are special-purpose languages for manipulating the registers and memory of a von Neumann-style computer. The majority of their syntax is devoted to arithmetic and Boolean expressions, and while they provide some facilities for forming data structures, they have poor mechanisms for procedural abstraction or control abstraction. In addition, they are designed for the state-oriented style of programming: computing a result by changing the value of variables through assignment statements.”

“Lisp, on the other hand, has no special syntax for arithmetic. Addition and multiplication are no more or less basic than list operations like appending, or string operations like converting to upper case. But Lisp provides all you will need for programming in general: defining data structures, functions, and the means for combining them.”

This is like the statement in the Preface of the Structure and Interpretation of Computer Programs:

“Underlying our approach to this subject is our conviction that ‘computer science’ is not a science and that its significance has little to do with computers. The computer revolution is a revolution in the way we think and in the way we express what we think. The essence of this change is the emergence of what might best be called procedural epistemology — the study of the structure of knowledge from an imperative point of view, as opposed to the more declarative point of view taken by classical mathematical subjects. Mathematics provides a framework for dealing precisely with notions of ‘what is.’ Computation provides a framework for dealing precisely with notions of ‘how to.'”

I had read the SICP quote before and knew it was important, but Norvig’s quote made it clearer for me.

Fortunately, the gulf between programming languages isn’t as great as it was in 1992 when PAIP was published. While languages like C and C++ are hard to beat for performance and OS interaction, newer languages like Python and Ruby (and even Java/C# with garbage collection) deal more with computation than direct hardware manipulation. Fortunately they haven’t followed Lisp in all ways!

I’m overwhelmed at the response to my recent article about Lisp: The Golden Age Isn\’t Coming Back, Let\’s Welcome a Bright Future! It clearly shows my blogging virginity that I’m excited about 4,000 page views, but that doesn’t make me any less excited! Not only that, there have been lots of good comments, almost 100 total, on this site, programming.reddit.com and Hacker News. I’d like to address some of the comments and criticisms in one place, here, rather than all over the place.

First, my mindset and perspective were poorly communicated and set the wrong stage going into the article. (I hate putting “WARNING” tags at the beginning of posts to set the right context, even though they are so useful!) A lot of people thought I was just another noob complaining about how hard it was to use Lisp. I mean, I guess I sort of was, but that wasn’t the point. The point was that Lisp has barriers to becoming a more popular, mainstream language, and every one of them is tractable! Here are a couple of the points, along with the solutions:

[Read more…]

I am a fairly new member of the Lisp community, so new that most people have never heard of me. I’m one of the young programmers that have read the excellent writing from Paul Graham, Raganwald, and Steve Yegge and decided to try Lisp out for myself. I’ve had much more time available in small chunks, enough to read tutorials and articles on the internet but not enough to dive into heavy programming. As a result, I’ve gotten to know the community and history better than the language and tools, probably better than any new convert. Here are some observations I’ve made (summary then detail):

1. Lisp is like a new language with lots of praise from important people.
2. Lisp used to be very important but lost that position.
3. Lisp lacks the infrastructure to get new users running quickly. The tools are there but they aren’t organized and streamlined.
4. The Lisp community is fractured but composed of enough good people that it could develop into a positive, influential force.

[Read more…]