Levi's Lisp Log

Guy Steele

Wed, 26 Jul 2006 22:16:55 GMT

Bookpool.com, an online computer bookseller, has put together a section where computer book authors list their favorite computer books from the last ten years. I wasn't familiar with many of the participating authors, but I was pleased to find Guy Steele among them.

His list of favorite books reveals a lot about him, and I hope to pick up some of them. The list is pretty well-rounded, from Knuth's Computers & Typesetting collection to The Annotated Alice and The Art of the Incredibles. Interesting stuff!

WireWorld Computer

Tue, 23 May 2006 22:15:03 GMT

You've probably heard of cellular automata before, at least in the form of Conway's Game of Life. There's another intereating cellular automaton called WireWorld, which performs a model of electrical signal propagation across a grid.

A couple of dedicated souls decided to create a fully-functioning simulated computer in Wireworld. This is a wholly remarkable feat, considering the simplistic nature of Wireworld itself. The computer has another interesting property in that it only has a single instruction, yet is fully Turing-complete thanks to special-purpose registers.

Bugfixes

Tue, 23 May 2006 07:06:47 GMT

I fixed a couple of bugs in the comment system tonight. First, there was a problem where an incorrect answer to the spam question would erase the fields entered into the comment form, which was inconvenient to a would-be commenter who I am sure accidentally typed the wrong answer.

The cookie that keeps track of the fact that you answered the question was set to only be valid for the current archive directory, so it only worked for posts made in the current month. It is now valid for the entire blog.

I also fixed an issue with the display of commenters' names who decline to leave a URL. The names now display in plain text instead of as a link to the current page.

Denotational Semantics

Tue, 23 May 2006 04:05:54 GMT

A friend of mine showed me some examples of the qualifying exams he'll have to take to get accepted into his Ph.D. program, and the Programming Language exams all asked the examinee to give the denotational semantics of a simple language for which the syntax was given.

Although I'm somewhat familiar with what it means to talk about semantics (as opposed to syntax and pragmatics), I'd definitely like to have a better understanding of how one actually gives a formal semantics of a language.

To this end, I did a little bit of searching, and found an out-of-print textbook entitled Denotational Semantics: A Methodology For Language Development. I've read through the first couple of chapters and the table of contents, and it seems like it's exactly what I was looking for.

So far, the introduction to the concepts has been clear, and the mathematics have been built up without too much prior knowledge expected. Some other CS theory textbooks have lost me in their heavy math from the get-go, so I'm glad my lack of experience with mathematical notation isn't holding me back on this one.

Brief Bio of Donald Knuth

Wed, 17 May 2006 21:58:34 GMT

Certainly one of the most revered of Computer Science's "founding fathers" is Donald Knuth, author of The Art of Computer Programming and the TeX document typesetting language. This month's Stanford Magazine ran a beautiful biography of Knuth, which briefly outlines his personality and achievements. It's a good read, and makes me hope that he will have many more years with us.

The Problem With Threads

Tue, 16 May 2006 19:53:39 GMT

I just read a Technical Report from UC Berkeley's EE/CS department entitled The Problem With Threads, which succinctly and clearly captures the problems with the concurrency mechanisms in our currently popular programming languages. It should be very readable to a lay programmer, since only a small section contains formalisms and most unfamiliar terms are defined in the text or footnotes.

To sum it up, threads (shared-memory concurrency) are an inappropriate method of bringing concurrency to a program because they destroy the inherent determinism of sequential programming languages. The tools we have to help deal with the nondeterminism only chip away at the combinatorial explosion of program interleavings, leaving so much opportunity for error that designing reliable and robust multithreaded software is futile.

The report notes that solutions to the problem that retain as much determinism as possible have existed for years, but have not caught on. The author suggests that instead of creating new programming languages, new coordination languages should be used to coordinate components written in familiar languages.

It's a very thought-provoking paper, and I think the conclusions are right on, as much as I'd like a new language to catch on. Massive concurrency is coming, and our current languages are not equipped to tackle it alone.

Goedel's Famous Proof

Sun, 30 Apr 2006 03:50:39 GMT

Kurt Goedel shattered the hopes of mathematicians who aimed to create a comprehensive formal theory under which all true statements of mathematics could be proved by proving that such a system could not exist. This incompleteness theorem has repercussions for computer science, since a limitation on formal systems is also a limitation on computer programs.

Martin Herzel has provided a translation of Goedel's famous proof from German to English and from Goedel's notation to more familiar contemporary notation. After reading about this proof from numerous other sources, it's great to be able to read it (almost) directly myself.

Wirth's Compiler Construction

Fri, 28 Apr 2006 18:18:24 GMT

PLT Online has added a new text to the library: Niklaus Wirth's Compiler Construction. This is a remarkably short book, yet it covers the essentials of building a compiler, from lexical analysis to code generation. The source and target languages used are now pretty obscure (though they should look familiar to anyone who's seen Pascal), but the great thing about theory is that it transcends implementation details. This would be a good text for a self-study student to use as an introduction to compiling.

SICP

Mon, 13 Feb 2006 05:19:34 GMT

I finally got around to picking up my copy of Structure and Interpretation of Computer Programs again, and I finished reading through the first chapter, Building Abstractions with Procedures. I've been programming in Scheme for a while, so the language concepts were mostly review, but the presentation was enlightening. Abelson and Sussman show how procedures, and later higher-order procedures, can be used to abstract complex numerical processes into simple, clear programs.

The second chapter covers data abstractions, which should be interesting. I'll probably work a few more of the exercises in this chapter than I did in the first. The temptation to just keep reading is pretty strong, but the exercises are where the bulk of the learning happens.

I imagine most people who would read a blog explicitly about Lisp are already somewhat familiar with the book, but if by chance you are not, I highly recommend reading it. And since it is available in full online, there's no excuse not to!

Markdown for Common Lisp

Fri, 10 Feb 2006 06:09:40 GMT

I've finally got my implementation of the Markdown text formatting language to a state where it's usable. It complies with almost all of the Markdown syntax specification, such as it is, and is comparable in execution time to the perl and python versions I tried it against.

It takes a string of Markdown-formatted text, processes it, and spits out an s-expression that can be fed into an HTML generator such as Peter Seibel's FOO (described here and part of this source package).

I'd be interested to get feedback on it; some bug-fixes, or suggestions for stylistic improvement would be appreciated. This is only my second Common Lisp program of any size, so it's bound to be sub-optimal. If you want to try it out or take a look at it, you can download it.

The Art of Metaprogramming

Sun, 05 Feb 2006 23:37:27 GMT

A technique I've found very useful lately, both at work and in hobby programming, is metaprogramming. That is, using programs to generate other programs. At work, I generate a large amount of C data structure initialization code from a spreadsheet and a Python script. It makes updating the data trivial and integrates right into the build process, eliminating all sorts of possibilities for errors.

There's a series of articles on DeveloperWorks covering the Art of Metaprogramming; see part 1 and part 2. Of course, they introduce Scheme, which is certainly one of the best languages to use for metaprogramming. Enjoy!

Fun with FFI

Fri, 20 Jan 2006 19:11:30 GMT

I recently received a task at work to implement a command-line tool that provides an interactive shell interface to a network protocol. Since the GNU Readline library provides a nice, familiar interface for that sort of thing, I looked for a high-level language I was familiar with that had readline bindings.

After a bit of investigation, I was unable to find one that looked usable. I did, however, discover that Chicken Scheme had an "egg" for readline integration. It didn't have all the features I needed, but it looked easily extensible.

The nice thing about Chicken (and a feature it shares with Gambit) is that it compiles to portable C code, so I wouldn't need an interpreter or runtime library to run the resulting application. This particular application might get distributed in the future, and we didn't want to require a relatively obscure langauge runtime to be distributed with it.

It turns out that adding the feature I wanted wasn't quite trivial, thanks to some lack of clarity in the readline documentation and some in the Chicken manual, but thanks to some very helpful guys on the Chicken email list, I was able to get it figured out. I highly recommend Chicken if you've got requirements similar to mine!

A CS Reading List

Tue, 10 Jan 2006 18:42:37 GMT

I just came across a list of classic texts in Computer Science that seems to run the gamut of CS topics. They're mostly rather old, but still very relevant. I've already read a few of them, and those ones are indeed classic, so I'm excited to read the rest when I get a chance.

On the same site, there is also a list of the site author's favorite books, of which I own and have at least skimmed through most. I agree that they are great books.

Elsewhere, there are some lecture notes by Daniel Friedman describing applications of continuations that look to be an interesting read.

Code Synthesis

Sat, 17 Dec 2005 03:46:55 GMT

When searching for information about techniques used to efficiently run dynamic code, I came across a dissertation that lines up well with the things I've been thinking about lately. It covers the design of an operating system called Synthesis, named for its technique of synthesizing optimized kernel code at run time.

In addition to dynamic code optimization, Synthesis uses non-locking optimistic concurrency and dynamic scheduling based on run time analysis to achieve incredible performance; by some measures, it is an order of magnitude faster than the Unix it was compared with, and it achieves the real-time scheduling necessary for multimedia work.

Although it was a very impressive achievement, it has since been nearly forgotten, and has now lost much of its usefulness since it was written in assembler code and the Motorola 68k architecture it targeted has fallen out of favor. The ideas seem applicable to higher-level language, though, especially Lisp-like languages in which code is easily manipulated at run time.

I certainly haven't the time to implement such a thing right now, but it's an intriguing idea. I think I will collect resources that might be useful for it. After all, if I continue my schooling, I'll need a dissertation topic too.

The Other Fundamental Concept

Fri, 16 Dec 2005 07:55:57 GMT

I recently had a rather unpleasant blog discussion with someone who is attempting to design a programming environment. I was initially drawn there by references to Alan Kay and Lisp, so I was rather disappointed to find that he completely discarded the essence of Kay's philosophy and some of the key technologies that allow Smalltalk and Lisp to work. He wrote endless, rambling tirades against bytecode-based virtual machine emulators and garbage collection, and heaped praises upon the ability to program at the assembly level.

He completely missed another prime candidate for the fundamental concept of programming, an oft-quoted Butler Lampson aphorism:

All problems in computer science can be solved by another level of indirection.

Coming from a man who did a significant portion of his work with computers in the 60s and 70s, when efficiency really was paramount, that ought to give an abstraction-hater pause.

Indirection is the key to abstraction, and abstraction is the key to programming. Throwing out useful abstractions because they're not the most efficient way possible to do something is entirely missing the point of computers.

Software and Concurrency

Sun, 04 Dec 2005 07:08:29 GMT

As I was doing research for a paper, I hunted down Herb Sutter's article The Free Lunch Is Over: A Fundamental Turn Towards Concurrency in Software to find some passages that supported my thesis. There was quite a buzz about this article when it appeared in Dr. Dobb's Journal and C/C++ Users Journal earlier this year, as it seemed to capture and clearly explain the feeling so many people had been getting while watching what the CPU manufacturers have been doing lately. Everything's going multi-core, even video game processors.

Following a few links, I found that Sutter has written (with James Larus) another article on the subject, this time with a greater focus on software. It's Software and the Concurrency Revolution at the ACM Queue, and it's a broad look at the deficiencies of current programming languages and practices in the face of concurrency, and what sort of changes need to be made to face the future he sees, in which individual processor cores don't get much faster than they are today.

I'm convinced that Sutter's take on the future is at least mostly right, and these articles ought to be required reading for anyone who wants to take up or continue writing software.

Futamura Projection

Tue, 15 Nov 2005 06:00:48 GMT

Every once in a while you come across something that just blows your mind. Having been reading textbooks and research papers on programming languages for a while, I thought I had already had most of the mind-blowing experiences to be had in that domain, but I couldn't have been more wrong.

Partial evaluation is an optimization technique in which the compiler analyzes the program to find any static portions of code and pre-evaluate them. In the 1970s, Yoshihiko Futamura described what is now known as Futamura Projection. There are three levels of Futamura Projection. The first takes an interpreter and a program as input and returns what is essentially a compiled version of the program. The second applies an interpreter to itself and creates a compiler for that languages. The third, and most mind-bending, takes itself twice as input and creates a compiler generator, which is a program that takes an interpreter as input and returns a compiler.

I have no idea yet what sort of practical use the Futamura Projection has, but it is at least a theoretically fascinating concept.

Fundamental Idea of Programming

Fri, 28 Oct 2005 01:25:23 GMT

According to Hal Abelson in his foreword to the book Essentials of Programming Languages, the most fundamental idea in computer programming is this:

The interpreter for a computer language is just another program.

On the face of it, this seems not to apply to compiled languages, or programs written in machine code. But, upon reflection, it does. The interpreter for these languages is the microcode on the CPU, and the interpreter for the microcode is a logic program expressed in physical transistors.

In any case, the concept of an interpreter program is a powerful one, and is certainly worth study and mastery. As Sussman says, you will become "a designer of languages rather than only a user of languages, [ . . . ] a person who chooses the rules by which languages are put together, rather than only a follower of rules that other people have chosen."

Sussman at OOPSLA

Tue, 25 Oct 2005 19:06:42 GMT

Gerald Sussman is one of the contemporary luminaries of the field of computing, so I'm always interested to hear what he has to say. His most recent talk, delivered in San Diego last week at OOPSLA, defended the idea that programming is a good medium for expressing ideas that we don't yet fully understand. It forces us to translate from theory to practice in a methodical fashion.

The abstract for his talk can be found at the OOPSLA site, and a great summary and response to it was written up by Eugene Wallingford at his blog, Knowing and Doing.

Analytical Engine Emulator

Wed, 12 Oct 2005 05:16:51 GMT

In 1837, Charles Babbage wrote a memoir entitled On the Mathematical Powers of the Calculating Engine. In this paper, he described a machine, steam powered and made of brass, that would be able to store and run general-purpose programs. While it was never fully constructed, Babbage's Analytical Engine was the first computer to ever be designed.

Usually computer emulators are designed to mimic computers that actually existed, but fortunately for the curious, someone has put together a Java-based Analytical Engine Emulator for the really-retro computing enthusiasts to play with. I haven't got the time nor inclination to write programs for it myself, but I think Babbage would appreciate his idea being brought to virtual fruition.

Speaking of programming the thing—although it was never built, it did have programs written for it. In fact, the very first was written by Ada Lovelace, who thus has the distinction of being the first computer programmer. It is sadly ironic that a field pioneered by women such as Ada and Grace Hopper, inventor of the first compiler, now finds itself with very few women practicing its arts.