should be glad of an Opportunity to serve others by any Invention
of ours, and this we should do freely and generously.”
—Benjamin Franklin, quoted in Benjamin Franklin by Edmund
S. Morgan.
Why I wrote this book
This is the fifth edition of a book I started writing in 1999, when I was
teaching at Colby College. I had taught an introductory computer science
class using the Java programming language, but I had not found a textbook
I was happy with. For one thing, they were all too big! There was no way my
students would read 800 pages of dense, technical material, even if I wanted
them to. And I didn’t want them to. Most of the material was too specific—
details about Java and its libraries that would be obsolete by the end of the
semester, and that obscured the material I really wanted to get to.
The other problem I found was that the introduction to object oriented
programming was too abrupt. Many students who were otherwise doing well
just hit a wall when we got to objects, whether we did it at the beginning,
middle or end.
So I started writing. I wrote a chapter a day for 13 days, and on the 14th
day I edited. Then I sent it to be photocopied and bound. When I handed it
out on the first day of class, I told the students that they would be expected
to read one chapter a week. In other words, they would read it seven times
slower than I wrote it.
vi
Chapter 0. Preface
The philosophy behind it
Here are some of the ideas that make the book the way it is:
❼ Vocabulary is important. Students need to be able to talk about pro-
grams and understand what I am saying. I try to introduce the min-
imum number of terms, to define them carefully when they are first
used, and to organize them in glossaries at the end of each chapter.
In my class, I include vocabulary questions on quizzes and exams, and
require students to use appropriate terms in short-answer responses.
❼ To write a program, students have to understand the algorithm, know
the programming language, and they have to be able to debug. I think
too many books neglect debugging. This book includes an appendix on
debugging and an appendix on program development (which can help
avoid debugging). I recommend that students read this material early
and come back to it often.
❼ Some concepts take time to sink in. Some of the more difficult ideas in
the book, like recursion, appear several times. By coming back to these
ideas, I am trying to give students a chance to review and reinforce or,
if they missed it the first time, a chance to catch up.
❼ I try to use the minimum amount of Java to get the maximum amount
of programming power. The purpose of this book is to teach program-
ming and some introductory ideas from computer science, not Java. I
left out some language features, like the switch statement, that are
unnecessary, and avoided most of the libraries, especially the ones like
the AWT that have been changing quickly or are likely to be replaced.
The minimalism of my approach has some advantages. Each chapter is about
ten pages, not including the exercises. In my classes I ask students to read
each chapter before we discuss it, and I have found that they are willing to
do that and their comprehension is good. Their preparation makes class time
available for discussion of the more abstract material, in-class exercises, and
additional topics that aren’t in the book.
But minimalism has some disadvantages. There is not much here that is
intrinsically fun. Most of my examples demonstrate the most basic use of
a language feature, and many of the exercises involve string manipulation
vii
and mathematical ideas. I think some of them are fun, but many of the
things that excite students about computer science, like graphics, sound and
network applications, are given short shrift.
The problem is that many of the more exciting features involve lots of details
and not much concept. Pedagogically, that means a lot of effort for not much
payoff. So there is a tradeoff between the material that students enjoy and
the material that is most intellectually rich. I leave it to individual teachers
to find the balance that is best for their classes. To help, the book includes
appendices that cover graphics, keyboard input and file input.
Object-oriented programming
Some books introduce objects immediately; others warm up with a more
procedural style and develop object-oriented style more gradually. This book
uses the “objects late” approach.
Many of Java’s object-oriented features are motivated by problems with pre-
vious languages, and their implementations are influenced by this history.
Some of these features are hard to explain if students aren’t familiar with
the problems they solve.
It wasn’t my intention to postpone object-oriented programming. On the
contrary, I got to it as quickly as I could, limited by my intention to introduce
concepts one at a time, as clearly as possible, in a way that allows students
to practice each idea in isolation before adding the next. But I have to admit
that it takes some time to get there.
The Computer Science AP Exam
Naturally, when the College Board announced that the AP Exam would
switch to Java, I made plans to update the Java version of the book. Looking
at the proposed AP Syllabus, I saw that their subset of Java was all but
identical to the subset I had chosen.
During January 2003, I worked on the Fourth Edition of the book, making
these changes:
❼ I added sections to improve coverage of the AP syllabus.
viii
Chapter 0. Preface
❼ I improved the appendices on debugging and program development.
❼ I collected the exercises, quizzes, and exam questions I had used in
my classes and put them at the end of the appropriate chapters. I
also made up some problems that are intended to help with AP Exam
preparation.
Finally, in August 2011 I wrote the fifth edition, adding coverage of the
GridWorld Case Study that is part of the AP Exam.
Free books!
Since the beginning, this book has under a license that allows users to copy,
distribute and modify the book. Readers can download the book in a variety
of formats and read it on screen or print it. Teachers are free to print as
many copies as they need. And anyone is free to customize the book for
their needs.
People have translated the book into other computer languages (including
Python and Eiffel), and other natural languages (including Spanish, French
and German). Many of these derivatives are also available under free licenses.
Motivated by Open Source Software, I adopted the philosophy of releasing
the book early and updating it often. I do my best to minimize the number
of errors, but I also depend on readers to help out.
The response has been great. I get messages almost every day from people
who have read the book and liked it enough to take the trouble to send in
a “bug report.” Often I can correct an error and post an updated version
within a few minutes. I think of the book as a work in progress, improving a
little whenever I have time to make a revision, or when readers send feedback.
Oh, the title
I get a lot of grief about the title of the book. Not everyone understands
that it is—mostly—a joke. Reading this book will probably not make you
think like a computer scientist. That takes time, experience, and probably a
few more classes.
ix
But there is a kernel of truth in the title: this book is not about Java, and
it is only partly about programming. If it is successful, this book is about a
way of thinking. Computer scientists have an approach to problem-solving,
and a way of crafting solutions, that is unique, versatile and powerful. I hope
that this book gives you a sense of what that approach is, and that at some
point you will find yourself thinking like a computer scientist.
Allen Downey
Needham, Massachusetts
July 13, 2011
Contributors List
When I started writing free books, it didn’t occur to me to keep a con-
tributors list. When Jeff Elkner suggested it, it seemed so obvious that I am
embarassed by the omission. This list starts with the 4th Edition, so it omits
many people who contributed suggestions and corrections to earlier versions.
If you have additional comments,
please send them to feedback@
greenteapress.com.
❼ Ellen Hildreth used this book to teach Data Structures at Wellesley
College, and she gave me a whole stack of corrections, along with some
great suggestions.
❼ Tania Passfield pointed out that the glossary of Chapter 4 has some
leftover terms that no longer appear in the text.
❼ Elizabeth Wiethoff noticed that my series expansion of e−x2 was wrong.
She is also working on a Ruby version of the book!
❼ Matt Crawford sent in a whole patch file full of corrections!
❼ Chi-Yu Li pointed out a typo and an error in one of the code examples.
❼ Doan Thanh Nam corrected an example in Chapter 3.
❼ Stijn Debrouwere found a math typo.
x
Chapter 0. Preface
❼ Muhammad Saied translated the book into Arabic, and found several
errors.
❼ Marius Margowski found an inconsistency in a code example.
❼ Guy Driesen found several typos.
Contents