Customer Reviews

A Little Java, A Few Patterns

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

 

 

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.

If you've ever wanted to learn object-oriented programming, or even if you've done some but have not been introduced to design patterns, this is the book I'd recommend. The emphasis is on the concepts behind the programming, rather than on the syntax of Java, so that it's appropriate even if you have no specific interest in Java. Only the most basic programming experience is needed to understand the book. I recommend working very slowly through the exercises, typing the programs in and testing them as you go. You won't have to shell out the bucks to buy a compiler, since Sun distributes theirs for free. By the end, you'll know about encapsulation, inheritance, and polymorphism, even though you won't realize it, and you'll also have had a taste of functional programming.

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.

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.

If you know what to expect from these authors, you'll enjoy this book. They progress slowly and orderly from simple methods towards more abstract, powerful ones.

You can and should read this book without a compiler present - this is more a thought book than a sit and work it out with your fingers book.

In conclusion, this book is of similar quality to the other books in this series - Little Schemer, Seasoned Schemer, Little MLer.

As with a good meal, your enjoyment will depend somewhat on your experience.

There are really only a few ideas in object oriented programming, but this is often obscured by the complexity of the language implementation, and is especially the case with JAVA, which has such a robust library. If you are trying to get at the essential concepts by browsing the library, you frankly will be unlikely to see the forest for the trees. This book glides lightly over the forest. If you love programming for its potential for elegance, then read this book--if it's strictly a practical affair for you, then skip it, it will seem too removed.

Decades ago, a predecessor of this book introduced me to Lisp. At first, the
cutsey Q&A style put me off, but that book, "The Little Lisper", succeeded very
well in its goal of creating a Lisp-speaking recursive mindset for me. Likewise
this book creates a Java-speaking, object-oriented mindset. However, not the mindset
you may think you want when you start reading. This book is a true sequel to "The
Little Lisper" and not an out-of-the-box Java patterns book. My first reaction
was "this is really neat but not necessarily too useful". Wrong. It wasn't long
before I was designing an open source Java package that stacks Swing objects in
a way strongly reminiscent of the stacked pizza toppings in this book. Who
knows? You, too, may end up stacking boxes rather than thinking within them.

This is a book of 'why', not 'how.' If you are interested in the nature of computation and curious about the very idea behind object orientation, this book is for you. This book will engage your brain (if not your tummy). Through its sparkling interactive style, you will learn about three essential OO concepts: interfaces, visitors, and factories. A refreshing change from the 'yet another Java book' phenomenon. Every serious Java programmer should own a copy.

A Little Java, A Few Patterns is an amazing book. With just a few "key strokes" the authors explain the essence of classes and object-oriented programming. They show patterns "in action", how to apply them, how they work. They don't bother you with the mind-numbing syntactic details of Java, but cut right to the "bone" of the language: classes, abstract classes, inheritance. If you want to create your own high-level pictures of this exciting new language, this book is it!

Students in both my introductory level classes and my graduate classes have used the book to quickly learn and use advanced object-oriented patterns.

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.