A Little Java, A Few Patterns

This book is to Java what the Little Schemer (same author) is to scheme. Though, more concepts are covered in the Little Schemer (esp. at the end). Nevertheless, this book like the little schemer teaches recursive thinking and programming by: user defined types and their respective operations. This is the key theme throughout this book and is not mentioned explicitly. Some of the patterns mentioned are composite, visitor, decorator, and template. The humor is subtle and the style and tone are friendly--which is necessary for the complexity of the material. On a related note, all the reviewers giving this book 1 star are obviously people looking for 'yet another java book.' One viewer noted its style of code, which I found wonderfully elegant. The structure of the book was also criticized: questions and answers. This teaching styling of asking instead of telling is very effective and fresh. Last point to make: this book teaches OO design much better than most simply because of the focus on object design/relationships rather than java syntax (which 'yet another java book' has covered mind-numbingly well). For java specific books (for most programmers) this book and Effective Java will be plenty.

I first read and enjoyed "The Little Lisper" in College (1990ish). It was entertained and educated at the same time. This was the first book I saw that "broke the mold" of computer programming texts. I bought "A little Java, A Few Patterns" because it was recommended to me. I was very pleasantly suprised to see the same approach used in the Little Lisper. I enjoyed this new book just as much and learned even more. This is a book for thinking programmers. It won't teach you Java syntax. It will help you learn how to think about what you are doing.

First a bit on the Kindle version: One star is subtracted for the electronic conversion. I fully understand that they needed a fixed layout and font-size in order to keep the original two-column layout work with the code examples without overflowing, but this comes at the cost of losing all the benefits of the layout that Kindle provides. The font also looks a bit weird - possibly a pdf->mobi conversion with OCR. Reading on my regular Kindle is taxing, but it is ok. The screen size of the Kindle DX is probably a far better match, as is my computer screen, but I cannot stand to read using that for long. I managed to read it on my Kindle, but it was annoying. Just a word of warning. As to the actual content of the book, I found myself enjoying it (after a while). I have to admit that there were some frustrations/questions that were nagging me for most of the book, but they were dealt with when just a tenth of the book remained. This was due to the author's wish to gradually build up a sense of how one ends up with the final version of the Visitor pattern, but I am unsure of the real value in showing so many less desirable versions of it first. The style is very reminiscent of The Little Schemer (TLS), a book I have on my shelf, but one I never finished - mostly due to not knowing how to run the code. This book actually starts with a section on how one can test the code, so that is not a problem here. The other difference from TLS is that I read this book with a good working knowledge of Java. Thus I never felt the need to actually test any of the code. One problem I have with the book is its class hierarchy and the names given to classes. The examples often use food classes and one of them is the shish kebab and its ingredients. There we have a class Shish and several ingredients like Onion, Lamb, etc that subclasses Shish. I find that very weird. I would think that a Shish HAS-A ingredent, not that an ingredient IS-A Shish. If the author had just somewhat refactored the classes to use composition I would be OK with the whole thing. The other examples have the same problem. Other than the issues with how the class hierarchy was composed, the code is quite nice and what you end up with in the end is very elegant code. I believe that the reviewers that most violently object to the code have not been exposes to much advanced OO design before and anything else than getters and setters probably freaks them out. It is not a shining jewel in my book collection, but it is interesting and absolutely worth reading. The last 20% percent of the book makes the initial frustration quite worth it. In short, I recommend reading it, if just for the experience of the different teaching format.

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.

I read this book about 7 years ago; it is still in my bookshelf. I actually learned a lot of OO ideas from this little book which I think had been deceptively titled; it should have been named "A little book of OO patterns in java" -I thought it was an introductory book in java at that time and I end up learning about interface, abstract, patterns, etc. before I even compiled my first "Hello World" in java.

I'm a beginer at Java. This is really a "head" book about the language and its structure. Not a "nuts & bolts" how to do it book. The readings should be done in pieces and close together. After you read, you find yourself suddenly realizing something about the structure of the language. It stimulates thought. Definately a book on the mind-of-Java as a programming language system. You subtly absorb the concepts. The book feels philosophical in nature.

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.

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.

"A Little Java, A Few Patterns" really teaches OO design & implementation in Java.