The JDK from java.sun.com.
Even if you choose to use a third-party development environment, it’s
always a good idea to have the JDK on hand in case you come up against what
might be a compiler error. The JDK is the touchstone, and if there is a bug in
it, chances are it will be well-known.
The HTML Java documentation from
java.sun.com. I have never found a reference book on the standard Java
libraries that wasn’t out of date or missing information. Although the
HTML documentation from Sun is shot-through with small bugs and is sometimes
unusably terse, all the classes and methods are at least there. People
are sometimes uncomfortable at first using an online resource rather than a
printed book, but it’s worth your while to get over this and open the HTML
docs first, so you can at least get the big picture. If you can’t figure
it out at that point, then reach for the printed
books.
Thinking in Java, 1st
Edition. Available as fully-indexed, color-syntax-highlighted HTML on
the CD ROM bound in with this book, or as a free download from
www.BruceEckel.com. Includes older material and material that was not
considered interesting enough to carry through to the 2nd
edition.
Core Java 2, by Horstmann
& Cornell, Volume I—Fundamentals (Prentice-Hall, 1999). Volume
II—Advanced Features, 2000. Huge, comprehensive, and the first place I go
when I’m hunting for answers. The book I recommend when you’ve
completed Thinking in Java and need to cast a bigger
net.
Java in a Nutshell: A Desktop Quick
Reference, 2nd Edition, by David Flanagan (O’Reilly, 1997).
A compact summary of the online Java documentation. Personally, I prefer to
browse the docs from java.sun.com online, especially since they change so
often. However, many folks still like printed documentation and this fits the
bill; it also provides more discussion than the online
documents.
The Java Class Libraries: An
Annotated Reference, by Patrick Chan and Rosanna Lee
(Addison-Wesley, 1997). What the online reference should have been:
enough description to make it usable. One of the technical reviewers for
Thinking in Java said, “If I had only one Java book, this would be
it (well, in addition to yours, of course).” I’m not as thrilled
with it as he is. It’s big, it’s expensive, and the quality of the
examples doesn’t satisfy me. But it’s a place to look when
you’re stuck and it seems to have more depth (and sheer size) than Java
in a Nutshell.
Java Network Programming,
by Elliotte Rusty Harold (O’Reilly, 1997). I didn’t begin to
understand Java networking until I found this book. I also find his Web site,
Café au Lait, to be a stimulating, opinionated, and up-to-date
perspective on Java developments, unencumbered by allegiances to any vendors.
His regular updates keep up with fast-changing news about Java. See
metalab.unc.edu/javafaq/.
JDBC Database Access with
Java, by Hamilton, Cattell & Fisher (Addison-Wesley, 1997). If you
know nothing about SQL and databases, this is a nice, gentle introduction. It
also contains some of the details as well as an “annotated
reference” to the API (again, what the online reference should have been).
The drawback, as with all books in The Java Series (“The ONLY Books
Authorized by JavaSoft”) is that it’s been whitewashed so that it
says only wonderful things about Java—you won’t find out about any
dark corners in this series.
Java Programming with
CORBA, by Andreas Vogel & Keith Duddy (John Wiley & Sons, 1997).
A serious treatment of the subject with code examples for three Java ORBs
(Visibroker, Orbix, Joe).
Design Patterns, by Gamma,
Helm, Johnson & Vlissides (Addison-Wesley, 1995). The seminal book that
started the patterns movement in programming.
Practical Algorithms for
Programmers, by Binstock & Rex (Addison-Wesley, 1995). The
algorithms are in C, so they’re fairly easy to translate into Java. Each
algorithm is thoroughly
explained.
Extreme Programming
Explained, by Kent Beck (Addison-Wesley,
2000). I love this book. Yes, I tend to take a radical approach to things
but I've always felt that there could be a much different, much better program
development process, and I think XP comes pretty darn close. The only book that
has had a similar impact on me was PeopleWare (described below), which
talks primarily about the environment and dealing with corporate culture.
Extreme Programming Explained talks about programming, and turns most
things, even recent “findings,” on their ear. They even go so far as
to say that pictures are OK as long as you don’t spend too much time on
them and are willing to throw them away. (You’ll notice that this book
does not have the “UML stamp of approval” on its cover.) I
could see deciding whether to work for a company based solely on whether they
used XP. Small book, small chapters, effortless to read, exciting to think
about. You start imagining yourself working in such an atmosphere and it brings
visions of a whole new world.
UML
Distilled, 2nd Edition, by Martin
Fowler (Addison-Wesley, 2000). When you first encounter UML, it is daunting
because there are so many diagrams and details. According to Fowler, most of
this stuff is unnecessary so he cuts through to the essentials. For most
projects, you only need to know a few diagramming tools, and Fowler’s goal
is to come up with a good design rather than worry about all the artifacts of
getting there. A nice, thin, readable book; the first one you should get if you
need to understand UML.
UML Toolkit, by Hans-Erik
Eriksson & Magnus Penker, (John Wiley & Sons, 1997). Explains UML and
how to use it, and has a case study in Java. An accompanying CD ROM contains the
Java code and a cut-down version of Rational Rose. An excellent introduction to
UML and how to use it to build a real system.
The Unified Software Development
Process, by Ivar Jacobsen, Grady
Booch, and James Rumbaugh
(Addison-Wesley, 1999). I went in fully prepared to dislike this book. It seemed
to have all the makings of a boring college text. I was pleasantly
surprised—only pockets of the book contain explanations that seem as if
those concepts aren’t clear to the authors. The bulk of the book is not
only clear, but enjoyable. And best of all, the process makes a lot of practical
sense. It’s not Extreme Programming (and does not have their clarity about
testing) but it’s also part of the UML juggernaut—even if you
can’t get XP adopted, most people have climbed aboard the “UML is
good” bandwagon (regardless of their actual level of experience
with it) and so you can probably get it adopted. I think this book should be the
flagship of UML, and the one you can read after Fowler’s UML
Distilled when you want more detail.
Before you choose any method, it’s
helpful to gain perspective from those who are not trying to sell one.
It’s easy to adopt a method without really understanding what you want out
of it or what it will do for you. Others are using it, which seems a compelling
reason. However, humans have a strange little psychological quirk: If they want
to believe something will solve their problems, they’ll try it. (This is
experimentation, which is good.) But if it doesn’t solve their problems,
they may redouble their efforts and begin to announce loudly what a great thing
they’ve discovered. (This is denial, which is not good.) The assumption
here may be that if you can get other people in the same boat, you won’t
be lonely, even if it’s going nowhere (or sinking).
This is not to suggest that all
methodologies go nowhere, but that you should be armed to the teeth with mental
tools that help you stay in experimentation mode (“It’s not working;
let’s try something else”) and out of denial mode (“No,
that’s not really a problem. Everything’s wonderful, we don’t
need to change”). I think the following books, read before you
choose a method, will provide you with these tools.
Software Creativity, by
Robert Glass (Prentice-Hall, 1995). This is the best
book I’ve seen that discusses perspective on the whole methodology
issue. It’s a collection of short essays and papers that Glass has written
and sometimes acquired (P.J. Plauger is one
contributor), reflecting his many years of thinking and study on the subject.
They’re entertaining and only long enough to say what’s necessary;
he doesn’t ramble and bore you. He’s not just blowing smoke, either;
there are hundreds of references to other papers and studies. All programmers
and managers should read this book before wading into the methodology
mire.
Software Runaways: Monumental
Software Disasters, by Robert Glass (Prentice-Hall, 1997). The great
thing about this book is that it brings to the forefront what we don’t
talk about: how many projects not only fail, but fail spectacularly. I find that
most of us still think “That can’t happen to me” (or
“That can’t happen again”), and I think this puts us at
a disadvantage. By keeping in mind that things can always go wrong, you’re
in a much better position to make them go right.
Peopleware,
2nd Edition, by Tom Demarco
and Timothy Lister (Dorset House, 1999). Although they
have backgrounds in software development, this book is about projects and teams
in general. But the focus is on the people and their needs, rather than
the technology and its needs. They talk about creating an environment where
people will be happy and productive, rather than deciding what rules those
people should follow to be adequate components of a machine. This latter
attitude, I think, is the biggest contributor to programmers smiling and nodding
when XYZ method is adopted and then quietly doing whatever they’ve always
done.
Complexity, by M. Mitchell
Waldrop (Simon & Schuster, 1992). This chronicles
the coming together of a group of scientists from different disciplines in Santa
Fe, New Mexico, to discuss real problems that their individual disciplines
couldn’t solve (the stock market in economics, the initial formation of
life in biology, why people do what they do in sociology, etc.). By crossing
physics, economics, chemistry, math, computer science, sociology, and others, a
multidisciplinary approach to these problems is developing. But more important,
a different way of thinking about these ultra-complex problems is
emerging: Away from mathematical determinism and the illusion that you can write
an equation that predicts all behavior, and toward first observing and
looking for a pattern and trying to emulate that pattern by any means possible.
(The book chronicles, for example, the emergence of genetic algorithms.) This
kind of thinking, I believe, is useful as we observe ways to manage more and
more complex software
projects.
Learning Python, by Mark
Lutz and David Ascher (O’Reilly, 1999). A nice programmer’s
introduction to what is rapidly becoming my favorite language, an excellent
companion to Java. The book includes an introduction to JPython, which allows
you to combine Java and Python in a single program (the JPython interpreter is
compiled to pure Java bytecodes, so there is nothing special you need to add to
accomplish this). This language union promises great
possibilities.
Listed in order of publication. Not all
of these are currently available.
Computer Interfacing with Pascal
& C, (Self-published via the Eisys imprint, 1988. Only
available via www.BruceEckel.com). An introduction to electronics from
back when CP/M was still king and DOS was an upstart. I used high-level
languages and often the parallel port of the computer to drive various
electronic projects. Adapted from my columns in the first and best magazine I
wrote for, Micro Cornucopia. (To paraphrase Larry O’Brien,
long-time editor of Software Development Magazine: the best computer
magazine ever published—they even had plans for building a robot in a
flower pot!) Alas, Micro C became lost long before the Internet appeared.
Creating this book was an extremely satisfying publishing
experience.
Using C++,
(Osborne/McGraw-Hill, 1989). One of the first books out on C++. This is out
of print and replaced by its second edition, the renamed C++ Inside &
Out.
C++ Inside & Out,
(Osborne/McGraw-Hill, 1993). As noted, actually the 2nd edition
of Using C++. The C++ in this book is reasonably accurate, but it's circa
1992 and Thinking in C++ is intended to replace it. You can find out more
about this book and download the source code at
www.BruceEckel.com.
Thinking in C++, 1st
Edition, (Prentice-Hall, 1995).
Thinking in C++, 2nd
Edition, Volume 1, (Prentice-Hall, 2000). Downloadable from
www.BruceEckel.com.
Black Belt C++, the Master’s
Collection, Bruce Eckel, editor (M&T Books, 1994). Out of print. A
collection of chapters by various C++ luminaries based on their presentations in
the C++ track at the Software Development Conference, which I chaired. The cover
on this book stimulated me to gain control over all future cover
designs.
Thinking in Java, 1st
Edition, (Prentice-Hall, 1998). The first edition of this book won the
Software Development Magazine Productivity Award, the Java
Developer’s Journal Editor’s Choice Award, and the JavaWorld
Reader’s Choice Award for best book. Downloadable from
www.BruceEckel.com.