Customer Reviews

Java: Learning to Program with Robots

5 star:		(2)
4 star:		(0)
3 star:		(0)
2 star:		(0)
1 star:		(1)

 

 

I really like the approach used in this text. The robots world is useful in many ways:
1) it presents a very visual way to learn Java programming. Using small robot icons, students can navigate around a city grid as they develop programs using classes provided with the book (the concept is a greatly improved version of Karel the Robot of many years ago). The visual nature of the work allows students to grasp concepts quickly and have a great deal of satisfaction seeing immediate and graphical results of their work. "Hello world" is nice but why not move an object on a screen instead? Students who have never programmed before create very clever programs quickly. For example, by creating multiple robots, they immediately grasp the concept of threads and why they are needed.
2) It makes learning Java seem like creating a game with new challenges every chapter.
3) The idea of a rather large class library presents a realistic work environment to students. A company doesn't start building libraries of code the day they are hired. It is important that they learn to use existing libraries and understand how to extend them.
4) "Objects early" is an important approach in my opinion. Building classes in your first Object-Oriented Programming language experience can be intimidating when you are just learning what a class is. By presenting already developed classes, students can see how useful classes are, how important reusable code is, and how planning the library of code is important. They also have a better grasp of all OOP concepts before developing their own classes.
The best thing this book does, is present material in an order that leads the student to naturally ask at the end of every chapter, "OK, but can I do this instead...?" and the next chapter presents the answer to that question. For example, just as students are realizing that moving the robot (myrobot.move() to move 1 intersection) more than a single intersection at a time is a useful idea (the question "Can't I send the number of moves to the robot somehow?"), the author includes ways to do that. I have never read a programming text book that uses this approach as well as this one does.
5) Students begin to build their own classes in chapter 8. By that time, it seems natural to examine a situation with stepwise refinement in mind and to look at commonality of data elements for a class.

If you prefer to write a "Hello World" program and follow the very strict and predictable approach of many programming language texts, this book will not be comfortable for you. If you want to have some fun while learning Java, pick this book up and before you know it, you'll be lost in the robot world thinking of new things to do with them and exploring Java in creative ways.

I love this book. Every object oriented thing the reader learns with robots (up
to chapter 7 and without them after that) is applied to GUI at the end of each
chapter. Doing so makes the concepts stick because they are applied in two
different contexts (and you learn a little GUI along the way, which is nice).

You can see that the author is an experienced teacher and that he put a lot of
thoughts in the presentation. At the end of each chapter there is:

1/ a beautiful "concept maps" where the concepts introduced in the chapter are
laid out on a page and related to each other with arrows and short phrases. It
may sound messy but it's actually really clear and helpful for those of us who
happen to have a "visual memory"

2/ a summary of every solutions used to solve a particular problem in the
chapter. It turns out that those solutions are used over and over again, so
much so that those solutions are really patterns, and the author took the pain
of classifying and systematically presenting (and re-explaining) them at the
end of each chapter. It's not the actuals "Gang of four" design patterns, but
the systematic presentation used by the author is close to that used in the
"Gang of four" book, which constitutes a nice introduction to the subject. The
author actually introduces a few "real" design patterns (and the MVC pattern
for GUI programming).

3/ the usual summary of things learned in the chapter

And each chapter starts with the list of things the reader will learn in the
chapter.

Of course, at the end of the book there are the usuals index and annexes, but
there is also the not so usual glossary which is another mark of the author
thoughtfulness.

Of course, illustrations are beautiful, clear, precise and to the point. There
are UML diagrams (every diagram is explained in due course), flowcharts, screen
shots, etc.

The author sometimes also uses short socratic dialogues.

There is an entire chapter clearly and explicitly explaining how to solve
simple problems using stepwise refinement, the first problem solving technique
a beginner should master. The author also explain how to trace a program, so
that you can convince yourself your program do what you expect. The authors
also gives good advises about style and good practices.

I usually don't like books using their own librairies because they usually are
used to hide presumably difficult things (usually IO), but instead of making
the transition to the real thing easier they make it more difficult. On the
contrary, the library used in this book, and more generally the robot metaphor
is used to expose everything in due course and to make things easily
understandable, not to hide them. With this book, when comes the time to use IO
(System.out, System.in, Scanner, file IO, etc.) it only seems natural.

One last thing, this book isn't dry, the robot metaphor makes it really fun,
that is it makes you actually take pleasure thinking about important
programming and design concepts. So, I might say that this book is "seriously
fun" as opposed to "Head-First-fun" or "Dummies-fun" or "In-21-days-fun" or
whatever book using childish humor (or graphics) every two phrases. In my
opinion, humor is a pedagogical tool like any other, and, as such, it shouldn't
be overused, but the actual trend seems to favor books overusing jokes,
graphics, and other flashy stuff, but different strokes for different folks.

In conclusion, the author uses like a virtuoso all the pedagogical tools at it
disposal making this book the state of the art in pedagogy of the best kind.

Really a wonderful book.

Hubert Dupont.

I really have to hand it to the author of this book. He has made the process of learning Java boring as well as painful! If you wish to torture yourself, don't buy one of the many other books on Java - especially not one of the best-sellers, and especially not one that's been recommended by other people who are actually programmers. No, get this book - I assure you that you'll experience firsthand the meaning of the word "tedium". Pair the purchase of this book with a college course on Java taught by someone who lacks people skills, and you're on your way to a world of pure pain!