Programming in Dylan

Craig, Iain D.
Date finished: 2001-01-05

This book is a decent overview of the Dylan programming language, though not a great one. The book's largest fault is that chapter 3 is rather useless, expending 50 pages on a sample program to track a grocery list database. This example is hopelessly contrived, and the most interesting topics for a programming language -- I/O, modules, libraries and interfaces -- aren't demonstrated by the sample program at all. After about 10 pages I started getting bored, and after 10 more pages gave up and skipped the rest of the chapter, with no adverse effect on my understanding of the rest of the book.

The rest of the book goes through the Dylan language feature by feature, using small toy examples to show each feature, which is just the approach I like for programming languages. There are a fair number of LaTeX markup bugs, but the largest flaw with the rest of the book is that Craig doesn't seem quite sure if it's an informal overview or a formal description. In some sections obscure features are skipped; for example, Dylan's for statement has several variations, and not all of them are explained. In other sections the description is tediously complete; the full process of method invocation, taking into account regular parameters and keyword parameters and #rest parameters, is explained in step-by-step detail that wouldn't look out of place in a standard document. These sections are dull, but can be readily skipped.

Judging by this book, Dylan is quite an elegant language, showing its ancestry as a Lisp descendant, but with a more conventional Pascalish syntax instead of a parenthesis-heavy Lisp syntax. At times the language feels remarkably Pythonic because it offers much of the same flexibility in argument calling and in manipulating classes, but Dylan adds optional static typing and offers more ability to lock down things than Python does.

It's unfortunate that Dylan now seems to be effectively moribund: Apple abandoned it; the sole commercial version from Functional Objects appears to be comatose; and Gwydion Dylan, the free compiler originally from CMU, doesn't appear to have a sufficient developer population to maintain and extend it enough to keep the software viable. One problem is that a Dylan compiler is much more like a Lisp compiler than like a C compiler and is correspondingly more complex; while reading the book I could vaguely imagine how I'd write an interpreted version of Dylan, but writing a compiler, even a stupid compiler, seemed much more difficult. Like Modula-3, Dylan can serve as an example of a good language that sadly never became widespread, but deserved to be better known.

Tagged: programming languages


%T  Programming in Dylan
%@  2001-01-05
%A  Craig, Iain D.
%K  programming languages

Contact me