What's on Ted's Bookshelf?
Several people have asked me for a list of "recommended reading" on several
subjects within Computer Science. I've promised this list so many times, I
finally gave up stalling and decided to create one. :)
Please note that these recommendations are entirely personal--there are some
books I recommend quite strongly, because I enjoyed reading the book or found it
to be thoroughly educational. (One or two are on the list because I wrote them
or helped in their creation--fair warning!) This is not to claim that my
preferences are in any way scientific or based on some kind of poll; it's my
personal recommendations, nothing more. If a well-known book isn't on the list,
however, you can safely assume that I've looked at it (I do a LOT of shopping at
bookstores), and I didn't care for it, didn't think it really added anything to
the volume of material out there already, or felt the authors' opinions or facts
are misplaced. (I'm an opinionated guy, I admit it.)
By the way, the books I've had a hand in show up in
brown. That way, you can be forewarned about my
inherent biases. :)
Note that the list is far from complete; it'll likely be incomplete for a
very long time, as I've got a LOT of books on my bookshelf, some of which
I want to share with you, some of which I want to warn you away from. :)
I've arranged the books by subject. Books whose title show up in red
are books you should read, regardless of technical bent (Java, .NET, whatever):
Patterns are an interesting concept in software design, modeled after
architectural (as in buildings, not software) patterns first described by
Christopher Alexander in his book "A Timeless Way of Building". In essence, a
software pattern describes a solution to a problem with certain
forces to yield a set of consequences. By examining the set of
patterns, and comparing our own problems and their forces, we can benefit from
the experiences of those who've "been there before", regardless of domain.
Unfortunately, too many patterns books (including one semi-popular 3-volume
set of books on patterns in Java) focus too much on the "solution" aspect of
patterns, and ignore the "forces" and "consequences" parts, which I believe are
by far the most important areas of any pattern. An easy way to tell if a patterns
book falls into that category is to examine the "consequences" section of any
particular pattern--if there's no negative consequences to the pattern, then
the author doesn't understand the Zen of patterns.
- Design Patterns by Erich Gamma, Richard Helm,
Ralph Johnson, and John Vlissidies The seminal work on patterns,
this book (also known within the patterns community as the "Gang of Four" or
"GOF" book), is the must-read first stop on understanding patterns. Pay
particular attention to the first chapter, where the essential principles
behind how to use patterns are described. Without understanding that
first section, the rest of the book (and, in fact, the genre) is useless to
you.
- Component Software by Charles Szyperski
This is the seminal work on components and component-oriented programming.
Despite what you might read from other places, components are not
objects all over again--there are some clear differences between a
component and an object, and its the inability to tell the two apart that
leads Java programmers to build terrible systems in EJB, and COM/.NET
programmers to build terrible systems in COM+.
Java, from Sun Microsystems is many
things, all wrapped up under a single marketing term, "Java". It defines a language,
a virtual machine, and a set of libraries, all for creating general-purpose
programs that stretch from the Palm Pilot PDA to enterprise applications that
run on massive servers.
One of Java's core principles has, from the very beginning, been "WORA",
an acronym for "Write Once, Run Anywhere"--the idea that Java code, once
compiled into .class files, will be executable on any platform that has a Java
Virtual Machine installed on it. Unfortunately, this promise turned out to be
far less feasible than originally envisioned, and Sun was eventually wise
enough (perhaps "forced" would be a better term?) to break Java into three
separate platforms: Java2 Micro Edition, Java2 Standard Edition, and Java2
Enterprise Edition.
The books below will be mostly J2SE- and J2EE-centric, reflecting my general
preference for doing enterprise-level software. I've tended to focus more on
aspects of the JVM, as well as on networking and enterprise-level software.
Java General-Purpose
- The Java Language Specification (3/E) by James Gosling
Definitely the canonical work on the Java language, it talks minimally
about the underlying Virtual Machine, which is where I believe all of the
real power of Java lies.
- The Java Virtual Machine Specification by Tim Lindholm and Frank
Yellin Now this is the book every Java programmer should have
memorized--without knowing the platform underneath the language, a Java
programmer can't begin to understand what's important. For example: in JDK
1.1, Sun was able to introduce inner classes into the language. One
particularly interesting facet of inner classes is that an inner class
implicitly has access to the
private members of the enclosing
outer class instance. But they were able to make this work without
changing the virtual machine in any way--how?
- Inside the Java2 Virtual Machine by Bill Venners The layman's
guide to the JVM; read this if you can't stand reading specs. Venners does
an impressive job of explaining the complexities of ClassLoaders, Threads,
Security, and other JVM-level topics.
- Server-Based Java Programming by Ted Neward
I wrote this to try and explain why EJB wasn't necessarily the best solution
for all enterprise Java software projects. It got some pretty good reviews,
particularly from some people who had already experienced some of the
inherent complexity and ugliness that EJB can impose.
Java Networking/Remoting
The Jini Specifications (2/E) by the Jini Team
Jini is one of my "hot topics" right now, and this book is the single dead-trees
version of all the current (as of Jini 1.1) specifications. It's not easy
reading, probably best read after another, gentler introductory (Jini
is not simple) Jini book.
Java RMI by ??? (O'Reilly)
A good book explaining the nuts-and-bolts of the Java Remote Method Invocation
protocol and stack. Essentially, one can view RMI as nothing more than
"sockets, serialization and classloading", and this book takes an approach
not too far from that; it first introduces streams, then serialization,
talks briefly about ClassLoading, then brings RMI into the picture and shows
how RMI builds on top of these concepts. If you're doing something with
EJB and/or Jini, you need to understand RMI, and this book is a good place
to start.
In-progress
The following books are still on my "in-the-process-of-reading" list:
- Java Deployment with JNLP and WebStart by Mario Marinilli
This is the first book (besides my own) that even mentions the idea of
Java code deployment, the act of pushing the compiled binaries out to the
target machines or clients. Just for that, it probably merits inclusion on
the "recommend" list, but I'm going to give it a read and see if it lives
up to the expectations I have (which, I'll admit, are fairly low--a new
subject like this requires some discussion before we extract the nuggets
of gold within it).
Why learn something that's already been obsoleted (by .NET, in this case)?
Because COM, the Component Object Model, was the first technology platform to
eschew components over objects, and its components that we're all interested in
building these days. Reading and studying COM, even if you never actually have
to use it in production code (I haven't), helps gain a deeper understanding of
what component-oriented systems (like EJB or .NET) are trying to do.
- Essential COM by Don Box
The seminal work on COM. In particular, you MUST read the first
chapter--it is, without a doubt, the best-written piece of prose in the
entire realm of technical/programming books. Aside from the Szyperski book,
this is also probably the best introduction to the idea of "components" in
software, and how they're different from objects.
Security
- SSL and TLS by Eric Rescorla
The seminal work on the Secure
Socket Layer and its successor, Transport Layer Security. If you're thinking
about security (which, according to [Viega00], you should be), then you're
thinking about using SSL/TLS for providing confidentiality when doing
communications across TCP/IP. If you're thinking SSL/TLS, then you have to
be thinking about reading this book--it not only describes how SSL/TLS
works, but also those areas where SSL/TLS might not be the most
appropriate mechanism to use.
- Building Secure Software by John Viega and Gary McGraw A book
whose time should have been ten years ago, before we got so deeply
into the habit of writing software to meet market demands. Viega and McGraw
talk specifically about the act of building software that's less vulnerable
to the common kinds of attacks (such as buffer-overrun attacks), and take
great pains to point out that no language/platform/environment (not
even the "secure-from-the-ground-up-language" Java) is entirely immune to
the kinds of attacks a malicious hacker might attempt. Definitely worth
reading, particularly if you are building 24x7 publicly-accessible systems
(like web apps).
Networking
- TCP/IP Network Programming (Vol 1) by W. Richard
Stevens
- TCP/IP Network Programming (Vol 2) by W. Richard
Stevens
- Effective TCP/IP by ???
Last updated 20 Dec 2001