A Little Java, A Few Patterns

Rating:
Summary: Socratic approach to OOP and design patterns
Review: Caveat: I have taken several classes from Dr. Felleisen and enjoy his pedagogical approach.

The book follows the philosophical Q&A format popularized by Socrates such that the reader is visually presented with questions on the left-hand side of the page and answers on the right-hand size of the page. One is expected and encouraged to actively participate in the book's pseudo-dialogue.

While some experienced programmers and novices who are pressed for time in their work and studies may decry the lack of a "straightforward" presentation: that is precisely what this book intends to avoid. A desire to improve & expand one's thinking processes in the context of programming are all that is required for enjoying and benefiting from this book.

Excellent for undergrad OO programming classes.

Rating:
Summary: Interesting Approach To Pattern Learning
Review: Good book. Very interesting style that I like. The question and answer format (if you don't cheat by just looking at the answers) is very good for helping you to learn the material. The concepts in this book can be applied to a number of problems and helped me to clarify the patterns covered by the book.

Rating:
Summary: Don't bother checking out this one...
Review: If you're looking for a curiosity, buy this book-like object. If you're at all interested in a practical volume on patterns and Java, you'd learn more by by watching the patterns your money made as you throw it into the breeze.

The book's format is horribly non-conventional, and that may appeal to the egghead in some people, but for the vast majority of people, you'll be very unhappy you purchased this useless book. In fact, to prevent anyone else from getting burned, I won't be looking to sell mine as a used book, just to keep it off the market; if you're an egghead looking for a coffee table book, buy it from someone else.

Rating:
Summary: You _must_ read it. One of a kind.
Review: There's nothing that approaches what this book can do for a beginning Java programmer. The greatest hurdle newcomers face in encountering Java (and OO) for the first time is the idea of defining rich new types that interact in tightly-constrained ways. This book is like saying "we're going to get really good at working with types and hierarchy -- GET OVER IT." I can barely talk to a programmer who hasn't mastered these conecpts, and this book is the antidote.

Because of the unusual structure of the book, there is no way to skim the book or to miss the key concepts. You can't fool yourself into thinking you get it -- you have to actually work through it. It's not a book about a language, it's a book about programming in a much deeper way than almost any other book I can think of.

At first, I was put off by the peculiar style of the code in this book. It's not a lot like the OO code I see and write on a daily basis. But it is not an issue -- the book is not prescribing a way of programming, it is exposing the intricacies of an object-oriented type system. I've never seen anything that even comes close to that goal, and this book absolutely succeeds in it. Once you "get over it", you are empowered to write code in a more familiar Java style, but with much greater insights about the design choices you face at every turn.

This is probably not the _only_ Java book you should read, but it is the only one you _must_ read.

Rating:
Summary: Not A Book For The Short-Sighted
Review: This book does not take the route of other Java books. Instead of trying to cover not only the basics of Object-Oriented Development, UML, Java syntax, and it's extensive library of functions, all with their own argot, this book approaches programming from a completely different angle. The book is easy to read, and is in a open, playful tone. Because the book is written in the Socratic method of question and answer, with each question and answer building on the last question and answer, the concepts are covered in a natural manner, that is easy to follow. As an example, before you even know that you have covered Abstract classes, and the benefits of poly-morphism in Java programming, you have seen it in action, and why it's beneficial. Situations like this abound, and broaden your deeper understanding of Java. If you're looking for a quick book to learn the syntax of Java, or something to cover the basics of the class libraries, stay away. If you want to know Java on a much deeper level, and be extension, programming on a deeper level, but this book.

Rating:
Summary: Forces you to think
Review: This book uses a "programmed learning" technique that many will find unfamiliar. There are questions on one half of the page, answers on the other. For each question, you should first try to answer it yourself, then read the book's answer, then go on to the next question. Some questions are trivial, others require a lot of thought. If you read the book in the way described, you won't just be told some things about Java, OOP, design patterns, and so on: you'll have to think about them yourself. This "question and answer" approach can be very effective, but you have to be willing to take the book on its own terms. It's unlike any other Java book you'll see.

It's important to remember that the book is an introduction, that it's not very long (less than 200 pages), and that it aims to introduce some of the fundamental concepts appropriate to Java rather than to explore the endless details of the language and its libraries. As such, it is very good, and a pleasant break from the style of more conventional Java texts.

The authors have written similar books about Lisp (which is where they started), Scheme, and ML.