There were next-to-zero technical books available for the Kindle shortly after its launch. I was delighted to discover 4 of the 12 books that were finalists for Jolt Awards this year are now available in Kindle form:

• Geekonomics
• Outside In Software Development
• WPF Unleashed
• xUnit Test Patterns

I second Andrew Binstock's recommendation of "The Definitive ANTLR Reference" by Terence Parr (author of ANTLR), even to Binstock's sly observation that the book "sort of lulls you into the false belief that you could write a new scripting language fairly easily."

I really like ANTLR. Not long ago, I was asked if it was even remotely feasible to essentially screen-scrape a complex mainframe-generated report. Other people were saying "weeks and even then no guarantees..." With ANTLR and ANTLRWorks, I wrote a parser in a day (albeit one with rules named things like "MysteryBlock1"). (I also pestered the client -- "No, seriously! If you want me to write parsers and hand that AJAX crap off to someone else, I'd be willing to make the sacrifice...")

My first reaction to the book xUnit Test Patterns: Refactoring Test Code by Gerard Meszaros (Addison-Wesley) was shock: 800 pages on writing unit tests? Isn't that taking things a little too far?

I have a problem calling such an omnibus a "patterns" book. At 800 pages, xUnit Test Patterns is twice the size of Fowler's original Refactoring or Scott Ambler's Refactoring Databases. The value of patterns, in large part, came from creating a common vocabulary. I think it's perfectly legitimate to be discussing a problem and say "Visitor pattern" and expect that the response should be "Well, let's see..." I don't think that would be a legitimate expectation if I said "Hard-Coded Test Double."

Having said that, the omnibus of snippets has been a trend lately: the Cookbook series from O'Reilly and the Recipes series from the Pragmatic Programmers. The idea seems to be to beat Google at the "quick reference" problem: when faced with a problem, what's the fastest way to find a related snippet?

At that level, if you mentally retitle Meszaros' book "xUnit Cookbook/Recipes" then I think it accomplishes the job admirably: it seems to cover just about every problem scenario I could quickly think of. On the other hand, how many problem scenarios do you encounter running unit tests?

My take is that this is a good book to have in the shared library, but is unlikely to be fought over or, in the long run, thumb-worn and broken. I just don't see xUnit as being that complex or trouble-prone. And for those who don't "get" unit-testing, I think the book would be intimidating (even though a newcomer would do well to read the initial 275 pages, which amount to a book-within-a-book on unit testing).

If you're having trouble with unit testing, by all means, rush out and get it. But I can't help but feel that it could have been twice the book at half the length.

Charles Petzold and Jeff Atwood have gotten in a bit of a kerfluffle that, I think, is an unfortunate example of how online writing can escalate and over-dramatize disagreements between even two talented writers. I'm sure that Atwood appreciates Petzold's work and I'm sure that Petzold appreciates constructive criticism. I'm not going to link to the original posts, because I think that they were both perhaps overly curt and I don't want to fan any flames.

But I do feel strongly enough about the issue to say this: Petzold's Applications = Code + Markup is a very good book. It's dense in a good way (if you've been following the dustup, read the pages in Atwood's original post).

Petzold's work also has a conscious narrative philosophy. Petzold talked about this when he was writing the book. Atwood praises the layout choices made in another book (which I haven't read) and his arguments are credible. But Petzold, too, made deliberate choices on these very issues and I don't think that it's fair to dismiss those choices as if they were accidents of an outdated approach to book design.

DeveloperWorks interviewed Rosalyn Lum and I about the Jolt Awards (IBM was a big winner this year).

The easiest Jolt vote I've made in years was for stpBA Storyboarding, a product which every architect and team lead owes themselves to evaluate. I would say it is revolutionary, but it is better than that -- it simply makes the way you probably already work vastly more efficient.

Essentially, it is a product that transforms screen-based storyboards into requirements and work-items. Based on (and in) Microsoft Office, you mock up screens using Visio and link them together using arrows. And then it transforms that into work-items. That's it. Simple. Obvious. Just works.

I could say that storyboards are one of the few diagrams that are universally comprehensible and producible by designers, users, and developers. I could say that usage-centered design, as laid out by Larry Constantine & Lucy Lockwood, is the most efficacious way I know to elicit requirements. I could say that the downside of storyboards has always been tracing their detail to and from work-items, and so they've traditionally been a "write once" work product. But I don't need to say that, because it's all so obvious.

It's really an eye-opening product -- download it, install it in a VM, you'll be happy.

The only rub being that I really do mean "install it in a VM." That it is essentially a Visio plug-in is both a strength and weakness of Storyboarding. Today, it only works with Office 2003. An Office 12 version is in development, but this is the type of product that, once you've tried it, you don't want to be without. Like all Jolt judges, I make extensive use of virtual machines (the awarding of a Jolt to VMWare Lab Manager was no shock) but Storyboarding was one where I felt that tuning up a dedicated virtual machine was very much the "way to do it." Perhaps due to the opaqueness of Office as a plug-in host, getting Storyboarding up and running took a little tweaking. If I recall correctly, before I attached the VM to the Internet to register/validate Office, there was some silent error that led to features not being enabled. Also, the workflow within Storyboarding was not immediately obvious, since it relies on its own pane within Visio and the potential is not quite unleashed by "press the buttons left to right." It's not a long learning curve, but it's longer than learning Peggle.

Highly recommended. (Storyboarding, not Peggle. If you wish to ever have a productive day again, I advise you not try Peggle.)

The Jolt Awards were announced last night. The list of winners is below. We had some particularly competitive categories this year (in Technical Books, I advise you to simply fill your shopping cart with the finalists). Most delightful, this was a year where there was some real innovation, which I'll highlight in some individual discussions.

1. Books General

Jolt Winner:

• Agile Software Development by Alistair Cockburn (Addison-Wesley Professional)

Productivity Winners:

• Catastrophe Disentanglement by E. M. Bennatan (Addison-Wesley Professional)
• Practices of an Agile Developer by V. Subramaniam and A. Hunt (Pragmatic Bookshelf)
• Software Estimation Demystifying the Black Art by Steve McConnell (Microsoft Press)

2. Books Technical

Jolt Winner:

• Head First Object-Oriented Analysis & Design by B. McLaughlin, G. Pollice, and D. West (O'Reilly Media)

Productivity Winners:

• Code Quality by Diomidis Spinellis (Addison-Wesley Professional)
• Refactoring Databases by Scott W. Ambler and P. J. Sadalage (Addison-Wesley Professional)
• CSS: The Missing Manual by David Sawyer McFarland (O'Reilly Media)

Jolt Winner:

• AccuRev 4.5 with AccuWorkflow (AccuRev)

Productivity Winners:

• AnthillPro3 (Urbancode)
• Perforce SCM (Perforce)
• Team Foundation Server (Microsoft)

4. Collaboration Tools

Jolt Winner:

1. Confluence (Atlassian Software Systems)

Productivity Winners:

• Adobe Acrobat Connect Professional (Adobe Systems)
• NetBeans IDE (Sun Microsystems)
• TeamCity (JetBrains)

Jolt Winner:

• Visual Studio 2005 Team Edition for Database Professionals (Microsoft)

Productivity Winners:

• Coral8 Engine (Coral8)
• Dbdeploy (ThoughtWorks)
• SQL Refactor (Red Gate Software)

Jolt Winner:

• stpBA Storyboarding (stpsoft)

Productivity Winners:

• Corticon Business Rules Modeling Studio (Corticon)
• MagicDraw UML (No Magic)
• Stylus Studio 2007 XML Enterprise Suite (DataDirect Technologies)

Jolt Winner:

• NetBeans IDE (Sun Microsystems)

 Productivity Winners:
IntelliJ IDEA (JetBrains)
IronPython (Microsoft)
Wolfram Workbench (Wolfram Research)

8. Enterprise Tools

Jolt Winner:

• Cape Clear ESB Platform (Cape Clear Software)

Productivity Winners:

• Liferay Portal (Liferay
• Appistry EAF (Appistry)
• Pentaho Open BI Suite (Pentaho)

Jolt Winner:

• NetAdvantage for .NET (Infragistics)

Productivity Winners:

• JViews (ILOG)
• .NET Framework 3.0 (Microsoft)
• Intel Threading Building Blocks (Intel)

Jolt Winner:

• Carbide .c++ Professional Edition (Nokia)

Productivity Winners:

• Crossfire (AppForge)
• NetBeans Mobility Pack and Sun Java Wireless Tookit (Sun Microsystems)
• Qtopia (Trolltech)

Jolt Winner:

• Rally Enterprise (Rally Software)

Productivity Winners:

• 6th Sense Analytics (6th Sense Analytics)
• Teamwork (Open Lab)
• V1: Agile Enterprise (VersionOne)

Jolt Winner:

• AppScan (Watchfire)

Productivity Winners:

• DevInspect (SPI Dynamics)
• Fortify Source Code Analysis (Fortify)
• Metasploit Framework (Metasploit)

Jolt Winner:

• AgitarOne (Agitar Software)

Productivity Winners:

• Mindreef SOAPscope (Mindreef)
• Parasoft SOAtest (Parasoft)
• TestComplete (AutomatedQA)

Jolt Winner:

• TestTrack Studio (Seapine Software)

Productivity Winners:

• JIRA (Atlassian Software Systems)
• OnTime 2007 (Axosoft)
• Software Planner Professional (Pragmatic Software)

Jolt Winner:

• VMware Lab Manager (VMware)

Productivity Winners:

• Adobe Captivate 2 (Adobe)
• ElectricCommander (Electric Cloud)
• Textmate (MacroMates)

Jolt Winner:

• Adobe Flex 2 (Adobe Systems)

Productivity Winners:

• IntelliJ IDEA (JetBrains)
• Mindreef SOAPscope Server (Mindreef)
• NetBeans Visual Web Pack 5.5 (Sun Microsystems)

Jolt Winner:

• Sun Developer Network (Sun Microsystems)

Productivity Winners:

• CM Crossroads (CMC Media)
• Koders.com (Koders)
• Krugle (Krugle)

HALL OF FAME

• IBM developerWorks (IBM)

I wasn't going to name names, because I do not know the vulnerability which allowed a rootkit to be installed on my system. I may well have been the source of whatever vulnerability by which the system was compromised.

But this "Hacker Safe" blaze front and center on the iPower homepage is infuriating. The blaze is provided by way of ScanAlert. Judging from the logs that I saw before I was disconnected and lost the system, multiple machines within the same subnet as mine were compromised. The technical support from iPower was beyond unhelpful: the "live technical support" is provided by a call center that is not physically located with the data center. After the initial problems on Tuesday, we requested a local reboot and tighter reconfiguration. They couldn't do it. Their only offer was to repave the machine and make it available to us over the Internet without any hardening of the attack surface! They couldn't even activate a firewall for us or modify the ACL. We told them to go jump in a lake earlier today -- four days after we discovered the compromise. Oh, and they're not refunding us any of the $7,000 or so we paid to set up (multiple) servers with them.

iPower is "Hacker safe"? I suppose so, in a sense.

Highly not recommended.

Normally, I don't have a lot of problems making decisions like this, but I've changed my mind 3 times about which book will get my top vote in this year's Jolt Awards for Technical Books. This is a very, very good set of books:

Books (Technical)

Code Quality (Addison-Wesley) by Diomidis Spinellis

How to Break Web Software (Addison-Wesley) by M. Andrews, J. Whittaker

Java Concurrency in Practice (Addison-Wesley) by Brian Goetz et al

Rails Recipes (Pragmatic Bookshelf) by Chad Fowler

Refactoring Databases (Addison-Wesley) by Scott W. Ambler and P. J. Sadalage

Head First Object-Oriented Analysis and Design (O'Reilly) by B. McLaughlin, G. Pollice and D. West

Ruby Cookbook (O'Reilly) by Lucas Carlson and Leonard Richardson

CSS: The Missing Manual (O'Reilly) by David Sawyer McFarland

Peter Coffee, who's been providing some of the most insightful, technically-based discussions of the IT and software industries for 18 years, has left eWeekto become Director of Platform Research at Salesforce.com. This is a significant loss to the field (although I am sure a great benefit to Salesforce.com). When I was an editor, especially at AI Expert, Peter used to keep me honest with pointed questions about the depth and accuracy of what we were publishing; one of my major regrets of my tenure as an editor is that I never got Peter to write for me.

In the years since, I've always looked forward to his columns. Peter always provided a great enterprise-level focus to his discussions, even as he stayed grounded in the realities of the programming experience. I think he's the most trustworthy development tool reviewer of the past decade, providing an invaluable service to countless developers at thousands of companies.

Well, so it goes. I wish the best to Peter and his family on this new direction....

Change and Configuration Management

AnthillPro3 (Urbancode)

Automated Build Studio (AutomatedQA)

FLEXnet Connect (Macrovision)

Perforce: the Fast Software Configuration (Perforce Software)

Team Foundation Server (Microsoft Corporation)

CA Wily Introscope ChangeDetector (CA / Wily Technology)

Collaboration Tools

Adobe Acrobat Connect Professional (Adobe Systems)

Code Collaborator (Smart Bear Software)

Confluence (Atlassian Software Systems)

NetBeans IDE (Sun Microsystems)

Sugar Professional (SugarCRM)

TeamCity (JetBrains)

Database Engines and Data Tools

Coral8 Engine (Coral8)

dbdeploy (ThoughtWorks)

MarkLogic Server (Mark Logic)

SQL Anywhere (Sybase iAnywhere)

SQL Refactor (Red Gate Software)

Visual Studio 2005 Team Edition for Database Professionals (Microsoft)

Design and Modeling

Compuware OptimalJ (Compuware)

Corticon Business Rules Modeling Studio (Corticon Technologies)

MagicDraw UML (No Magic)

RAVEN (Ravenflow)

stpBA Storyboarding for Microsoft Visual Studio 2005 Team System (stpsoft ltd.)

Stylus Studio 2007 XML Enterprise Suite (DataDirect Technologies)

Enterprise Tools

Cape Clear ESB Platform (Cape Clear Software)

Liferay Portal (Liferay)

Mule (MuleSource)

Appistry EAF (Appistry)

Pentaho Open BI Suite (Pentaho)

TeamCity (JetBrains)

Libraries, Frameworks and Components

JViews (ILOG)

NetAdvantage for .NET (Infragistics)

telerik r.a.d.controls for WinForms (Telerik)

.NET Framework 3.0 (Microsoft)

Intel Threading Building Blocks for Linux (Intel)

Microsoft XNA Game Studio Express, XNA Framework (Microsoft)

The Mono Project (Novell)

Mobile Development

AccuSPEECH (Vangard Voice Systems)

Carbide .c++ Professional Edition (Nokia)

Crossfire (AppForge)

Qtopia Greenphone (Trolltech)

NetBeans Mobility Pack 5.5 and Sun Java Wireless Tookit 2.2 (Sun Microsystems)

Qtopia (Trolltech)

Project Mangement Tools

6th Sense Analytics (6th Sense Analytics)

DevPlan (TechExcel)

Rally Enterprise (Rally Software)

TargetProcess (TargetProcess)

Teamwork (Open Lab)

V1: Agile Enterprise (VersionOne)

Security

AppScan (Watchfire)

beSTORM (Beyond Security)

DevInspect (S.P.I. Dynamics)

Fortify Defender (Fortify Software)

Fortify Source Code Analysis (SCA) (Fortify Software)

Metasploit Framework (Metasploit)

Automated Testing Tools

AgitarOne (Agitar Software)

CodePro AnalytiX (Instantiations)

Mindreef SOAPscope (Mindreef)

Parasoft Jtest (Parasoft)

Parasoft SOAtest (Parasoft)

TestComplete (AutomatedQA)

Bug and Defect Tracking Tools

JIRA (Atlassian Software Systems)

OnTime 2007 Hosted (Axosoft)

Software Planner Professional (Pragmatic Software Co.)

TestTrack Studio (Seapine Software)

Utilities

Adobe Captivate 2 (Adobe Systems)

AutoPatch (SourceForge)

ElectricCommander (Electric Cloud)

TEKchecker and StyleWriter (ClearSpecs Enterprises)

TextMate (Macromates)

VMware Lab Manager (VMware)

Web Development

Adobe Flex 2 (Adobe Systems)

IntelliJ IDEA (JetBrains)

Kapow Mashup Server (Kapow Technologies)

LignUp Communications Application Server (LignUp)

Mindreef SOAPscope Server (Mindreef)

NetBeans Visual Web Pack (Sun Microsystems)

Web Sites/Developer Networks

CM Crossroads (CMC Media)

IBM developerWorks (IBM)

Sun Developer Network (Sun Microsystems)

Koders.com (Koders)

Krugle (Krugle)

Makezine.com (O'Reilly)

The Code Project (The Code Project)

I'm the moderator of the "Development Environments" category of the Jolt Awards and this year the finalists are:

Development Environments

• EiffelStudio Open Source Edition (Eiffel Software)
• IntelliJ IDEA (JetBrains)
• IronPython (Microsoft)
• Microsoft XNA Game Studio Express, XNA Framework (Microsoft)
• NetBeans IDE (Sun Microsystems)
• Wolfram Workbench (Wolfram Research)

This makes for three interesting match-ups at the "sub-category" level: EiffelStudio and IronPython are primarily language-driven, IDEA and NetBeans are broadly capable Java heavyweights, and XNA and Wolfram Workbench are for the development of specialized types of applications. Oh, how I wish the judges' discussions could be published.

Books (Practical/General Developer Interest)

Agile Software Development: The Cooperative Game (Addison-Wesley) by Alistair Cockburn

Catastrophe Disentanglement (Addison-Wesley) by E. M. Bennatan

Eric Sink on the Business of Software (Apress) by Eric Sink

Practices of an Agile Developer (Pragmatic Bookshelf) by Venkat Subramaniam and Andy Hunt

Software Creativity 2.0 (DeveloperDotStar) by Robert L. Glass

Software Estimation: Demystifying the Black Art (Microsoft Press) by Steve McConnell

Weinberg on Writing: The Fieldstone Method (Dorset House) by Gerald M. Weinberg

Books (Technical)

Code Quality (Addison-Wesley) by Diomidis Spinellis

How to Break Web Software (Addison-Wesley) by M. Andrews, J. Whittaker

Java Concurrency in Practice (Addison-Wesley) by Brian Goetz et al

Rails Recipes (Pragmatic Bookshelf) by Chad Fowler

Refactoring Databases (Addison-Wesley) by Scott W. Ambler and P. J. Sadalage

Head First Object-Oriented Analysis and Design (O'Reilly) by B. McLaughlin, G. Pollice and D. West

Ruby Cookbook (O'Reilly) by Lucas Carlson and Leonard Richardson

CSS: The Missing Manual (O'Reilly) by David Sawyer McFarland

Not a bad bookshelf...

Congratulations to all the finalists!

Microsoft has posted version 1.1.13.8 (whatever the heck that means) of their F# compiler, which gives me an excuse to discuss the book Practical OCaml by Joshua Smith.

Practical OCaml is a new release from APress. My favorite technical book of last year was Practical Common Lisp, by Peter Seibel, and I hoped that Smith could duplicate the feat. It looks like the book has a different editorial team, but follows some similar structural advice. Even if nothing else, both books are reasonably sized (~400 pages, not ~1,000) and divided in a manner that makes them very appealing for those interested in learning a programming language.

My main motivation for reading this book (other than the hope that APress had discovered a way to bottle the lightning of language evangelism) was that "pure" functional languages are inherently parallelizable. That is to say, the language semantics are such that a sufficiently smart compiler could correctly take care of threading the computation over multiple cores/processors. Since I am of the belief that the manycore era is going to require a sea-change in programming approaches, I think it behooves those interested in the future to gain experience with such languages. Concurrency is treated only tangentially in Practical OCaml and I am under the distinct impression that OCaml is not inherently parallelizable (I believe this to be the case with F# as well). Nonetheless, it's certainly true that concurrency is "easier to think about" when using functional approaches, so there're still things to be gained.

What I didn't realize was that OCaml is a very, very good language for writing domain-specific languages. It's pattern-matching semantics are quite advanced and lex/YACC libraries (ocamllex and ocamlyacc) are part of the standard distribution. While I feel that tools like ANTLR and concepts like Parsing Expression Grammars have the potential to displace lex/YACC, there's no questionthat lex/YACC is the dominant "species" in the world of compilers.

Having said all that, I'm afraid that Smith's book is not nearly as persuasive as Seibel's. I abandoned LISP long ago and Seibel made me reconsider that decision. I wanted to learn OCaml but could hardly sustain my enthusiasm through the first chapter. The first sentence of Practical Common Lisp is "If you think the greatest pleasure in programming comes from getting a lot done with code that simply and clearly expresses your intention, then programming in Common Lisp is likely to be about the most fun you can have with a computer." That's a good opening and I think accurately captures the undeniable aesthetic appeal of LISP. The first sentence in Smith's "Why OCaml?" introduction is "It's a fair question." That's a bad opening. At least, it's a bad opening when followed by five paragraphs whose greatest substantive claim is "OCaml helps the programmer to easily express normal concepts and actually express difficult concepts." If that doesn't take the wind out of your sails, rest assured that it is preceded by "Returning to the title question, if I were to answer the question in more mundane terms, I would say that...." That's the type of opening that calls into question the author's precision.

The tutorial that follows is structured well-enough, but the concepts are not presented as well as they could be. Here is the complete discussion of the I-would-think-important concept of mutable variables:

It can be tempting to use mutable references, but I suggest that you resist that temptation. I have generally found that, except in a few cases, the use of a mutable reference could be removed by fixing my designs.

This is not a rule in any sense of the term because sometimes a mutable reference is really the best choice. File input/output (I/O) is a good example because file I/O is often a nonfunctional chore. Some other functional languages deal with these nonfunctional chores by using monadic computation, but that might not always be necessary.

You can hide mutable references in OCaml classes to make their use less problematic (this is discussed in more detail in Chapter 19).

This is on page 23 and is not preceded by a discussion of why mutable references are undesirable or what monadic computation is...I can't resist: the index has only 1 reference for "monadic computation" and that leads to page 251's explanation that:

Monadic computations and monads in general are creations that open up a small loophole for purely functional languages. Although a purely functional language cannot have functions with side effects, it can have values that describe and contain side effects. This boils down to computational sleight-of-hand that comes with a cool-sounding name.

Oh. Alright then. I started the book under the impression that issues of mutability might be fairly important to understanding a functional language, but apparently they aren't.

APress is 1-for-2 with their Practical... series, I hope Practical Haskell comes up to bat next.

In the meantime, if you want a really good book I suggest: Practical Common Lisp.

Compilers: Principles, Techniques, & Tools 2nd Ed. by Aho, Lam, Sethi, & Ullman is the perfect book for two niches: people writing C compilers for embedded processors and CS students running the gantlet of compiler courses. I don't want to say that those niches don't exist and that for people in that situation The Dragon Book, as it's universally known, is anything but essential reading. For the rest of the world, that is, that broader-than-professional-compiler-writers-but-still-a-marked-subset-of-the-world-of-professional-programming niche, the book is not compelling.

The Dragon Book, as the text has been universally known, is widely considered a "hard read" and, like Shakespeare or Joyce, even a smart person reading it without guidance or prior exposure will have difficulty gauging the amount of attention one should give a particular point. It's near-universal reach probably does make it "the one book to have if you're having only one," and it's depth has kept it a spot on many a shelf for many a year, but in all honesty I found myself disappointed while reading it.

The entire second half of the book is devoted to optimization and OS- and machine-level code generation. It remains the definitive text on this subject, but this subject is outside the realm of interest for the large majority of people who might be interested in writing compilers. Today, most people interested in compiler construction are far more interested in language design issues than in chip-level instruction sets and graph-based optimizations. Whether a minority or a majority, I can't say, but many (potential) compiler writers are interested in targeting the CLR and/or the JVM and thereby embrace a simplified runtime environment.

It seems sadly out of touch with current debates: the index lacks references to, for instance, "duck typing" or "packrat parsing," two techniques that are unquestionably, on the one hand, "all the rage" and, on the other, theoretically intriguing. To not cover either, in a book that spends 200 pages on lexical and syntactical analysis, seems almost willfully pig-headed. The book covers its chosen principles in depth (bordering on "is this a book on compilers or automata theory?") but does not venture outside those lines.

Another instance: on page 966, in the appendix, there're two paragraphs discussing "object-oriented vs. phase-oriented" compiler design. To call that perfunctory is to be kind -- perfunctory coverage would at least mention theVisitor design pattern.

Again: just in the past few days, there's been talk about how one could / should generate method dispatch in a dynamic language. Joel Spolsky says that Ruby is slow because of method dispath. Avi Bryant says that's true, but only because of naive code generation (Ruby today does not follow The Hugunin Directive : "Use fast paths for common cases, using native constructs if possible.") Ted Leung refers to Avi's discussion as "the 20-year-old method of in-line method caching." The Dragon Book, in contrast, explains how to construct a stack frame.

Similarly, The Dragon Book spends a tremendous amount of time on "lexing" efficiently (lexical analysis is the first step of writing a compiler: transforming a stream of characters into a stream of tokens) and such is the influence of theory that I would be shocked to ever see a lexer not based on deterministic finite automata (DFAs). Anyone who ever wrote a lexer using, say, String.Split() and a hashtable would be banished from The He-Man's Compiler Writers Club. This despite the fact that such a lexer would be highly transparent in purpose and design and would almost certainly be able to handle any reasonably-sized source code input (I was going to qualify this, but for heaven's sake, we've got gigabytes and gigahertz today).

As for "tools," the discussion is solely focused on lex & yacc. A quick example of how creaky the discussion is: the one source code snippet showing input to lex shows a function that returns a pointer and whose signature specifies it as returning an int. So...there's a piece of C code that hasn't been updated in twenty years. True, lex & yacc are the ancestors of virtually every compiler-construction tool. More's the pity, as the general design of these tools could be made recognizable to those who've used tagging languages like PHP or ASP. For that matter, a generation that's familiar with DOMs and XML parsers brings more than a blank slate to the tasks of tree-walking and rewriting.

So The Dragon Book sadly exemplifies the barriers-to-entry in the world of language design and compiler construction. This is a great book for the 500 teams worldwide building C compilers (yeah, seriously, there are hundreds of C compilers). For better-or-worse, it's undoubtedly the textbook of choice for many CS curricula. It is not a good text for those interested in today's active debates and discussions about language design and implementation.

This entry is hReview microformatted.