Author: Jay Bryant
Aimed at: Absolute Beginners
Cons: Poor organization and layout
Reviewed by: Alex Armstrong
If it wasn't for "Absolute Beginners" in the title this book might get a slightly better review - not that much better but few books are all bad.
Why it is that authors think that writing a book to teach programming to beginners is just a matter of "speaking slowly". I really don't know but it is usually what happens. In this case the book tries to present ideas slowly enough but it fails. The problem is made worse by the messy layout that makes even simple things look difficult.
A real "absolute beginner" has no idea what programming involves and has no concept of the way a program does its job and certainly doesn't have any higher concepts such as loops, selects, data or objects. So you need to spend a lot of time explaining not only how things work, but why they are necessary. Instead this book takes the "show them some code and they will understand" approach.
Chapter 1 starts out by getting the reader to install the JDK and Eclipse. This is not a good choice. Eclipse may be a good platform for the expert, and it maybe so good that the beginner will naturally move up to it later, but it is not a good choice for the beginner. It is a tricky IDE to use until you get used to its ways. In addition it doesn't come with a drag-and-drop UI designer, which is one of the easiest ways to get a beginner to understand objects, methods, properties and events. Again once past the beginner stage the programmer might well want to ignore a drag-and-drop editor in favour of code, but at the start it makes things much easier and allows the construction of GUI applications. Without it the book has to start off with console applications and this is both intimidating and unrewarding.
Once we get beyond Chapter 1 the book falls into the trap of following the sort of presentation more suitable for a reference work. So we start off with Chapter 2 on syntax and learn about classes, fields, methods constructors etc, all without much motivation and well before an absolute beginner could have any idea what is involved in constructing an algorithm to even to add a few numbers together. Chapter 3 moves on to data types, and it isn't simple already its into "wrapper classes" and arrays, Chapter 4 is on operators, and remember we haven't even had an if or a for introduced yet. Finally Chapter 5 does get to flow of control and gets the whole lot over in a single go - if, if else, switch, loops and even break and so on. This is simply going to leave the beginner high and dry. This is no way to introduce programming to the beginner.
Chapter 8 deals with objects and as this is the first chapter on objects you would be right to be surprised that it covers polymorphism and granularity.
Chapter 7 introduces the Swing library and for the first time we have a user interface to worry about but again it is all too fast and too complicated. Chapter 8 covers file handling and Chapter 9 XML - which is not a beginner's topic. Chapter 10 is on animation which is fun and, in the right book, could have been introduced earlier.
Chapter 11 deals with debugging, 12 video games, 13 garbage collection, 14 recursion and 15 generics and regular expressions. You can tell from the mad dash to the finish line that this is a book that feels it necessary to cover the ground - unfortunately it packs all this technical stuff into a total of 290 pages.
For a programmer wanting to convert to Java it might just have some value - although even in this case the presentation is messy and the examples are too complex. There are also places where it is misleading as to what the purpose of a facility is. This might be OK for the beginner as they are not going to be following this higher level stuff anyway, but to the more expert this matters.
If you are an absolute beginner than you could argue that Java is not a good place to start and this book seems to be proof of this. However it really isn't Java that is at fault but the organization, presentation and the selection of tools that makes the language seem much more difficult than it needs to be. Publishers need to learn that it is not enough to be a skillful and able programmer to write a book for beginners. It needs a reasonable understanding of what concepts beginners need to learn, how to get them across without unnecessary complications and an idea of what can be left until later.
This book has nothing at all to recommend it to the complete beginner and very little for the more general reader.