Mike Schaeffer's Weblog
Mon, 02 Jul 2007
A few interesing software books.

I wrote this list of good software books a few years ago, in an effort to write down books that I've found to be interesting and/or useful. None of these books are of the 'X in Y days' variety, and very few qualify as reference books likely to be useful in your day to day work. That said, move of them will still make you a better developer.

Software Structure and Algorithms

Steve McConnell

This book is a classic reference on how code should be constructed, when working at the level of program statements and functions. While it does not cover some of the newer programming constructs or languages, this book should be considered essential reading for any working programmer.

Jon Bentley

As the author puts in the preface, this book talks about the more glamourous aspects of programming. Culled from a series of articles in Communications of the ACM, Bentley presents a series of insights on solving common programming problems.

Donald Knuth

This is the series on the common algorithms used in software. Knuth presents, in gory detail, a series of algorithms and the mathematics on which they depend. You probably should not expect to read (or understand) everything that's here, but if you're in a bind, these books can be invaluable references. Robert Sedgewick also has an alternative that might be more accessible.

Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman

The definitive reference on compiler design. If you have to do anything with expression parsing, analysis, or translation this is a good introduction.

C and C++

Andrew Koenig

C is a language notoriously full of little oddities that can make programmers' lives more difficult. This book documents a lot of them, explaining a little about why the language works the way it does. Reading it is a good way to help become a more seasoned user of C (and by implication C++). Expert C Programming by Peter van der Linden also appears quite good too, although I've not read it all the way through.

Bjarne Stroustrup

Ever wonder why C++ works the way it does? This book, documenting the history of C++ and C with Classes, talks a lot about the design decisions made while the language was being developed. It's a dry read at times, but understanding the intent of the designers of a tool can really help while using the tool.

James Coplien

In the C++ world, this book is old: It predates the ANSI standard, and many of the features introduced later on in the standardization effort (like STL). Despite that, Coplien describes techniques that give C++ programs a level of flexibility approaching that of languages like Lisp and Smalltalk. He covers garbage collection, multi-method dispatch, and replacment of code at runtime, among other techniques. If you need those capabilities, I'd reccomend another language. If you have to use C++, I'd reccomend this book.

Win32 Programming

Brent Rector and Joseph Newcomer

This is one of the most detailed books on the core Win32 API I've ever seen. If you need to work with Win32, you need good documentation, and this is the book to get. Not only does it talk in great detail about API functions, it also talks about some of the differences between the various platforms extant in 1997. I can't reccomend it enough, but I do hope it gets updated to include Windows 2000 and XP.

Paul DiLascia

First things first: this book is centered around Windows 3.1. While a lot has changed, a lot has stayed the same about the Windows API. Keeping that in mind, DiLascia's narrative through the process of encapsulating the Win16 API in C++ is a perfect example of how to manage the complexity of a difficult API using an object oriented programming environment. Even if you never write a Windows framework yourself, it's still good reading on the issues involved in both Windows programming and framework design in general.

Graphics and Visualization

Foley, van Dam, Femer, Hughes

A good introduction to a wide variety of graphics algorithms and techniques. Serious work in the field will require more specialized books, however.

Edward R. Tufte

A good, and beautiful, discussion on how to graphically depict numerical information, and do so reliably and clearly.

Edited by Balachander Krishnamurthy

Not really a visualization or graphics book, except for the material covering the AT&T GraphViz (dotty and lefty) toolset. If you're programming with data structures more elaborate than lists, this tool can be an easy way to interpret data structures dumped to disk. With lefty, it's even possible to program specific user interfaces to edit graphical displays.

"Advanced" Languages

David Stutz, Ted Neward, and Geoff Shilling

This book is dense, but essential reading. With the two biggest emergent platforms (Java and .Net) depending on advanced runtime support, these more advanced runtime engines are now a fact of life. While this book focuses on the shared source implenentation of the .Net runtime, it is an excellent introduction to the ideas behind Java, .Net, and even languages like Smalltalk, Scheme, and Lisp.

Gregor Kiczales, Jim des Rivieres, and Danial G. Bobrow

This book documents something called the Metaobject-protocol as found in the object oriented part of some Common Lisp implementations. If you need to use metaobjects, it's of course a useful book, but it's also informative in general about the implementation of dynamic languages. I particularly liked the coverage on method dispatch and selection.

Guy Steele

While it's been superceded by the ANSI Hyperspec for Lisp, as a reference for Common Lisp, this is still a good reference to the language. For programmers in general, and particularly language implementors, this book is also full of good ideas on algorithms and software design.

Paul Graham

Macros (code-rewrite rules) are one of the hardest things to understand in Common Lisp, and other similar languages. Graham goes into a lot of detail about how they can be used in real-world development, and includes a bunch of good examples. It is available free of charge online.

Harold Abelson, Gerald Jay Sussman, and Julie Sussman

This is one of those books that has the potential to seriously change the way you think. Written as a textbook for an introductory programming course at MIT, this book talks a lot about varying styles of computation and how they can be used.

reddit this! Digg Me!

[/tech/general] permanent link