Think Java: How To Think Like a Computer Scientist - 2e
Chris Mayfield, James Madison University
Allen Downey, Franklin W. Olin College of Engineering
Copyright Year: 2020
ISBN 13: 9781491929568
Publisher: Green Tea Press
Conditions of Use
The book covers most topics that I would expect in a CS1 level course. One topic that is strangely missing is working with text files, which is something that can lead to more interesting beginning programs. The chapters themselves are fairly... read more
The book covers most topics that I would expect in a CS1 level course. One topic that is strangely missing is working with text files, which is something that can lead to more interesting beginning programs. The chapters themselves are fairly short and do not always cover all of the information that might be expected. This also means that there are a limited number of examples available for the students to look at. Some information is also not covered where it might be expected either. For example, the increment and decrement operators are not covered until chapter six, which is about loops.
The book is very accurate. I do not remember encountering any specific errors in the text or code provided. There might be some bias, which is because most programmers are biased about the way that they do things (e.g., Java programmers tend to go about coding differently than C++ programmers, etc.). I know that I disagreed with a few things in the book, and it was also very minor in the grand scheme of everything.
I think that this book will stay relevant for a while. The problems are with updating and modularity (see below). Adding in new features, such as Java Records, could take extensive work. (I do not think Records are really needed and some of my colleagues disagree.)
The book is very easy to read and follow. I would say that additional examples might be helpful in some areas, since only providing a single context is not always effective for reaching a large amount of students.
The book adheres to a consistent excellent style and grammatical framework.
This book, like most computer programming books, has modularity issues. Some chapters heavily rely on other chapters, so reordering the readings is challenging. Reordering or omitting chapters can also be problematic, because that content might be referenced later.
The book has great organization throughout. Sometimes I would have introduced things in a different order within a section or moved topics to different sections that made more sense to me.
The score for the interface varies a little depending on which version of the textbook is being used. The HTML version viewable from Green Tea Press has an alert that not all mathematical symbols might display correctly. The HTML Trinket version does not have this alert, however it does not have as good of a table of contents with direct links right to the sections like the Green Tea Press version. The actual mathematical operator symbols are not listed in the index, which might be confusing to some students if they wanted to refer to them.
I do not remember there being any grammatical errors during my reading of the book.
I do not recall there being anything insensitive or offensive in the book. It is possible that the example contexts could be expanded to be more inclusive of more backgrounds. This could be as simple as changing from using playing cards as an example and switching to using dice instead.
The book mentions using Dr. Java in the appendix, which is something that I thought about bringing up in the relevance area. I used to use Dr. Java for my CS1 courses and I liked it greatly. Eventually, I could no longer get it to work on Mac OS X, so I stopped using it. The last update to Dr. Java was also in 2019, which means that development on it might no longer be active.
The book is appropriate for a first semester Computer Science course, although it does not present every detail that a Computer Science professor may wish to cover in a first semester programming course. The instructor should plan to fill in... read more
The book is appropriate for a first semester Computer Science course, although it does not present every detail that a Computer Science professor may wish to cover in a first semester programming course. The instructor should plan to fill in small details in lecture or with supplementary reading, if those details are needed for whatever programming projects they wish to assign to the students.
Having taught using this book for two semesters, I cannot think of any inaccuracies.
The book begins by walking the reader through the mechanics of writing a very simple Java program. Throughout the book, the focus is on key concepts that a beginning Computer Science student needs to understand. The text also refers the reader to online reference materials, such as the Java Tutorial (https://docs.oracle.com/javase/tutorial/), where the student can find more detailed information.
I have had student feedback indicating that they found the book clear and easy to read.
I cannot think of ANY inconsistency.
The chapters are fairly short, making each one approximately appropriate for one week of classes.
Each chapter concludes with a summary of the vocabulary introduced in the chapter, as well as a number of exercises. There are several useful Appendices, and the sample programs that appear in the text are available for free download.
The book introduces a few concepts, such as recursion and inheritance, that some Computer Science departments may choose to defer to a follow-on (second semester) course. These are easy enough to de-emphasize, without sacrificing any continuity. It is also possible that a brief mention of a more advanced topic will encourage the students’ curiosity about Computer Science in general.
No issues found. As far as I know, all of the URLs to other resources are up to date.
No problems observed.
No problems found.
Java is an evolving language, so it would be impossible for any introductory textbook to cover every topic that a Java programmer is likely to encounter. However, this book provides a reader-friendly starting point, with helpful of links to more comprehensive resources.
I have used "Think Java" previously as a supplement to my notes in my sections of an introductory programming and problem solving CS1 level course in Java, and intend to do so again, but to emphasize use of the textbook more. The textbook covers... read more
I have used "Think Java" previously as a supplement to my notes in my sections of an introductory programming and problem solving CS1 level course in Java, and intend to do so again, but to emphasize use of the textbook more. The textbook covers all of the material required in CS1 except for File I/O. The text takes a "late objects" approach, mentioning just the minimum required about classes to explain how to write the first program. Search, sort, and recursion are covered. The table of contents and index provide a good road map to find topics of interest. Each chapter includes both a vocabulary list and a sample problem section.
Errors I had noticed in prior versions of the text have been corrected. Vocabulary is used in industry-standard fashion. All mentions of specific Java IDEs and tools are informational and relatively free of judgement.
While the field of computer science is constantly evolving, the approach taken by this text to teach the fundamentals is likely to survive. The newer features of the language in Java 9 and above are topics I would expect to see in the next course (CS2) beyond this textbook. That said, the inclusion of the Java2D features in the appendix may become dated if JavaFx truly takes off.
My primary reason for choosing this textbook is the conciseness and the clarity. The language used is straight-forward and direct, and the examples are very helpful. The vocabulary is defined both in context and in a separate vocabulary section. I can't say enough about the benefits of a concise textbook when a student is searching for one critical piece of information to cement his or her understanding of a concept. The only section where I have any issue with clarity is the discussion of higher-order, machine language, and byte code in section 1.3.
The textbook is highly consistent in both terminology and structure. The vocabulary sections ensure that all sections of the text access the concepts with the same terminology.
The textbook is about as modular as can be given the need for fundamental programming topics to build upon each other. The chapters are sufficiently small and further subdivided into bite-sized chunks. However, some of the authors' choices in topic order are locked in. For example, the authors choose to cover loops before arrays, and as a result use loops all through the material in the chapter on arrays, even though there may be other options to teach arrays that do not require the use of loops. Some of the more advanced material near the end and especially the appendices can be skipped without disruption.
The organization of the text is logical and flows well from section to section. The structure of each chapter makes it easy to navigate the text and find the required information.
I've used both the PDF and web versions of the text with no problems. The addition of even just a fancier cover would help with providing a more professional textbook appearance that the quality of the textbook deserves.
The textbook has been thoroughly edited.
The examples used are cross-cultural, although a surprising number of students in recent years are unfamiliar with standard card games.
"Think Java" covers the material for a CS1 class with just the right depth. The concise writing style, clear vocabulary definitions, and helpful examples make this text the right fit for my class.
Concepts are presented individually, in a fundamentals-first approach, with examples that are simple for students who are learning to program for the first time. It does not assume any previous knowledge of programming or college-level math. It... read more
Concepts are presented individually, in a fundamentals-first approach, with examples that are simple for students who are learning to program for the first time. It does not assume any previous knowledge of programming or college-level math. It presents the concepts well, without overwhelming the reader with long and complicated examples. It covers the topics for a fundamentals of programming course and even a good introduction to Object-Oriented Programming.
All the code is available on GitHub and instructions to use GitHub are provided in the book. It is a good way to give students some experience using code repositories. The exercises are at the right difficulty level to give students some practice.
The vocabulary section at the end of each chapter is useful.The index and table of contents are complete.
I have not found any conceptual errors in the book.
The basic programming concepts in the book will continue to be relevant. The code, tested in Java 8 (in book’s edition 6.1.3), should continue to work with new Java releases. New developments in the programming language can be added in newer editions.
The explanations and examples are clear and easy to follow. The exercise objectives and instructions are easy to understand, not confusing or intimidating. The terms are well-defined and the examples are familiar. The vocabulary section in each chapter is a valuable resource for students who need to review the terminology.
It is great that the author updated the textbook in response to the previous reviews. The book is very consistent now, with introductions in every chapter, as well as exercises and vocabulary. The introduction to OOP was moved to chapter 10 and the section on Java documentation was also moved to an earlier chapter. The terminology used is consistent throughout the book too.
The book is now divided in 14 chapters and 3 appendices. The size and section breakdown is good for a semester-long CS1 course. Some advanced topics can be skipped without disruption. The book is not overly verbose which gives students more time to work on their programs. Every chapter has well-defined exercises and students are encouraged to work on all of them.
The book is well organized and the topics flow in a logical fashion. Some of the issues from previous editions have been fixed. Introductions to every chapter are now available. My suggestion is to add a clear list of student outcomes for each chapter. That would be useful for students and instructors alike.
I reviewed the PDF version and it looks good. The links in the table of contents are working. There are clickable links within the text to different sections, such as appendices, and external websites. Having the code printed in color is very helpful. I also like that when a Java keyword is mentioned in the explanations, the font (face and color) of the keyword matches the font in the code samples.
I have not found any grammatical errors.
The text is neutral. The examples are current and unbiased. I have not found any insensitive references.
I found the book to be very accessible to the first-time programmer. It presents programming logic with simple, short examples. I intend to use it in my introduction course.
“Think Java” intends to provide all the topics needed for the beginners to learn Java programming. The vocabulary, comprehensive index, a variety of practice exercises at the end of each chapter, and the links to related material stimulate the... read more
“Think Java” intends to provide all the topics needed for the beginners to learn Java programming. The vocabulary, comprehensive index, a variety of practice exercises at the end of each chapter, and the links to related material stimulate the interest to learn. However, the text does not include a precise introduction and a concluding summary in many chapters. A sorted list of the vocabulary of all the terms can be presented as a glossary before the index.
The content is correct, easy to follow.
In the online version, the text for the following hyperlink shows ?? in Section 1.10. http://greenteapress.com/thinkjava6/html/thinkjava6001.html#code
Any textbook on programming concepts needs to reflect the evolution in the field by updating it periodically. It is essential to keep the users updated by extending a reference to the current Java 9 API documentation.
The author employs a clear and readable writing style with easy-to-follow illustrations.
The vocabulary section at the end of each chapter is neither sorted nor precise in some definitions. The definition of the term 'void method' is included in the vocabulary section of the value methods chapter.
The textbook consists of organized and manageable sections and sub-sections. Still, the void and value methods may be merged into a single chapter to enable readability and ensure continuity.
The text presents all the relevant information needed for a beginner progressively with a few structural issues.
The sections in some chapters are not organized with smoothly flowing content. For instance, Chapter 2 entitled "Variables and Operators" does not introduces all the most basic data types. A list of all the operators in Java is not presented in the same chapter. The modulus, relational, and unary increment and decrement operators are introduced in Chapters 3, 5, and 7 respectively.
The text flows clean and includes a useful collection of web-links for relevant reading material. The online version enhances both readability and interest by linking one concept to another.
No grammatical errors found.
The textbook is culturally unbiased.
Overall, the availability of the text in pdf, online and printed forms makes it a useful resource for the post-secondary learners.
The textbook covers all of topics for a post-secondary introduction to programming course in Java (CS1). The topics are presented in a "late objects" order. Each chapter includes a Vocabulary section that is a glossary of the terms introduced in... read more
The textbook covers all of topics for a post-secondary introduction to programming course in Java (CS1). The topics are presented in a "late objects" order. Each chapter includes a Vocabulary section that is a glossary of the terms introduced in that chapter. A comprehensive index is provided, as well.
The content is completely accurate, error-free, and unbiased.
The computer science concepts are up-to-date, generally. The only error that I found was with a link to the development tool, Checkstyle, in Appendix A. The project has moved from sourceforge.net to github at https://github.com/checkstyle/checkstyle. Because this was located in the Development Tools appendix, it should be easy to update in a future release.
One of the strengths of Think Java is how easily understood the writing is. Keeping the language clear is critical in explaining complex computer science concepts and this book does an excellent job.
I found it to be very consistent.
Reading sections are broken up into sections that are clearly distinguished in the table of contents. This is helpful if you choose to skip, for example, sections 5.8 Recursive methods and 5.9 Recursive stack diagrams because you don't teach recursion until the following semester.
Think Java is very well organized. It covers the core computer science topics using the Java programming language, while gently introducing more advanced concepts, such as the description of Java as a Turing complete programming language in section 6.7.
I read the book with iBook reader on my iPad and MacBook. In both cases it was very easy to navigate and all of the figures appeared correctly. I tested it briefly in Acrobat Reader and had no issues with navigating to the various sections.
I found no grammatical errors.
I found the tone culturally neutral. The examples are mathematics based or with familiar objects, such as a deck of cards.
The book does a great job on providing fundamental programming concepts in a manner that will make it easy for Students to grasp. Materials are organized in a reasonable manner, although the chapter on loops could be presented sooner. Each... read more
The book does a great job on providing fundamental programming concepts in a manner that will make
it easy for Students to grasp. Materials are organized in a reasonable manner, although the chapter
on loops could be presented sooner. Each chapter ends with Glossary to further help explain the terms
used in the chapter. Each chapter had a good amount of exercises at the end. Overall, the book is
very well done, and one that I would use in the classroom.
I did not find any errors. I reviewed about 80% of the presented code, and could not find any issues.
The book’s concepts on programming fundamentals will be long lasting. Java may change with new
Versions, but the code/syntax presented in this book is standard stuff, so it also should be long lasting
(at least as long as Java is in use).
The author is very deliberate in his explanations of using Java in solving problems and in the overall programming concepts. The author
does a very good job with presenting examples and explaining in detail each part of the example. Also there is a consistency in how each
example, or programming concept is presented.
As stated in the clarity part of the review, the author is very consistent in how he presents examples and concepts.
This is one of the strong points of the book, along with the easy simplistic way things are presented. Very easy for
Students to see the concept being presented and to understand how it is coded in Java. Some text books over complicate
the example, that is not the case in this book.
The text contains 16 chapters and four appendixes. All the chapters were fairly short in size, so that a Student would not get
over whelmed with anyone concept. Each chapter was broken down into concise parts, so that an instructor could easily assign
the whole chapter or sub-sections. The chapters are arranged in an order, such that the Student can easily flow from one concept
to the next, if reading the book in sequence. The one issue, the chapter on Loops should be presented earlier.
Please refer to the comments in the modularity section.
Overall, book is very well organized and structured to the point a Student
should have no issue going through the book and following the concepts
from one to the other.
The text was very clean and loaded with links to relevant material.
The book would benefit if there were some links with in the text to
assist in navigation. So one concept or example could be linked to
Did not find any grammar errors. Assume the text has been scanned multiple times by now.
The text deals with programming fundamentals, Java syntax, and logic. Not much in the way of cultural relevance in this topic, so it should not be offensive to any group.
Overall very impressed with the book and definitely one I would use in my classroom.
It has covered the topics that are expected to be covered in a beginning programming course. However, the structure and arrangement of the material is not smooth. Consistency in presentation is missing. read more
It has covered the topics that are expected to be covered in a beginning programming course. However, the structure and arrangement of the material is not smooth. Consistency in presentation is missing.
It is accurate, error-free and unbiased.
The links to the java documentation are provided with explicit URLs. It is unavoidable to update these when a new version of Java is released.
The life of programming text books is directly related to the evolution of the programming languages. For example, the latest version of Java is Java 8 and this text book is referring to Version 6.
Abstraction (giving and seeing big picture) is very important concept in Java. Some treatment with real world examples would be useful.
Some sub-sections in the individual chapters are out of place. For example "(8.5) Reading Documentation" is applicable to any chapter. It is best to cover and provide details on how to search and navigate java documentation in general in the first chapter itself.
It would be good to cover "Chapter 15. Object oriented programming" prior to chapters 12,13, 14.
This book lacks consistency.
Many chapters jump directly into the material while some chapters start with an introduction (example: 12 Arrays)
The text is well divided into chapters, sections and sub-sections
It is expected that each chapter starts with the goals of that chapter. "What is covered? What will I learn? Why should I read this chapter?" -- these questions should be addressed in the first few paragraphs of each chapter.
Many chapter directly jump to the topic and only a couple of chapters have this introduction.
Here are some issues I have found
While navigating the PDF, I can jump to a topic by clicking on the page number in the INDEX. However, you can not do the same thing from TABLE OF CONTENTS. It is very limiting to manually nagivate using "page down" or "search"
Didn't find any issues.
There are no offensive or insensitive references.
Chapters (3) and (6) can be combined into "methods". All the concepts explained in these two chapters are same with one distinguishing feature - one type returns nothing. Another type returns something. Rest of the concepts are same.
Table of Contents
- 1 Computer Programming
- 2 Variables and Operators
- 3 Input and output
- 4 Methods and Testing
- 5 Conditionals and logic
- 6 Loops and Strings
- 7 Arrays and References
- 8 Recursive Methods
- 9 Immutable Objects
- 10 Mutable Objects
- 11 Designing Classes
- 12 Arrays of Objects
- 13 Objects of Arrays
- 14 Extending Classes
- 15 Arrays of Arrays
- 16 Reusing Classes
- 17 Advanced Topics
- A Tools
- B Javadoc
- C Graphics
- D Debugging
About the Book
Think Java is a hands-on introduction to computer science and programming used by many universities and high schools around the world. Its conciseness, emphasis on vocabulary, and informal tone make it particularly appealing for readers with little or no experience. The book starts with the most basic programming concepts and gradually works its way to advanced object-oriented techniques.
In this fully updated and expanded edition, authors Allen Downey and Chris Mayfield introduce programming as a means for solving interesting problems. Each chapter presents material for one week of a college course and includes exercises to help you practice what you’ve learned. Along the way, you’ll see nearly every topic required for the AP Computer Science A exam and Java SE Programmer I certification.
About the Contributors
Chris Mayfield, PhD, is an Assistant Professor of Computer Science at James Madison University. His research focuses on CS education and professional development, particularly in K-12 schools. Over the past several years, he has taught introductory CS courses using POGIL and the flipped classroom.
Allen Downey is an American computer scientist, Professor of Computer Science at the Franklin W. Olin College of Engineering and writer of free textbooks.
Downey received in 1989 his BS and in 1990 his MA, both in Civil Engineering from the Massachusetts Institute of Technology, and his PhD in Computer Science from the University of California at Berkeley in 1997.
He started his career as Research Fellow in the San Diego Supercomputer Center in 1995. In 1997 he became Assistant Professor of Computer Science at Colby College, and in 2000 at Wellesley College. He was Research Fellow at Boston University in 2002 and Professor of Computer Science at the Franklin W. Olin College of Engineering since 2003. In 2009-2010 he was also Visiting Scientist at Google Inc.