A Little Java, A Few Patterns [Paperback]

Matthias Felleisen (Author), Daniel P. Friedman (Author), Ralph E. Johnson (Foreword)

Book Description

Publication Date: December 19, 1997 | ISBN-10: 0262561158 | ISBN-13: 978-0262561150 | Edition: First Edition

Java is a new object-oriented programming language that was developed by Sun Microsystems for programming the Internet and intelligent appliances. In a very short time it has become one of the most widely used programming languages for education as well as commercial applications.Design patterns, which have moved object-oriented programming to a new level, provide programmers with a language to communicate with others about their designs. As a result, programs become more readable, more reusable, and more easily extensible.In this book, Matthias Felleisen and Daniel Friedman use a small subset of Java to introduce pattern-directed program design. With their usual clarity and flair, they gently guide readers through the fundamentals of object-oriented programming and pattern-based design. Readers new to programming, as well as those with some background, will enjoy their learning experience as they work their way through Felleisen and Friedman's dialogue.

Editorial Reviews

Review

"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." Gary McGraw, PhD, Research Scientist at Reliable Software Technologies and coauthor of Java Security

About the Author

Matthias Felleisen is Trustee Professor of Computer Science at Northeastern University, recipient of the Karl V. Karlstrom Outstanding Educator Award, and co-author (with Daniel Friedman) of The Little Schemer and three other "Little" books published by the MIT Press.

Daniel P. Friedman is Professor of Computer Science at Indiana University and is the author of many books published by the MIT Press, including The Little Schemer (fourth edition, 1995), The Seasoned Schemer (1995), A Little Java, A Few Patterns (1997), each of these coauthored with Matthias Felleisen, and The Reasoned Schemer (2005), coauthored with William E. Byrd and Oleg Kiselyov.

Product Details

• Paperback: 200 pages
• Publisher: The MIT Press; First Edition edition (December 19, 1997)
• Language: English
• ISBN-10: 0262561158
• ISBN-13: 978-0262561150
• Product Dimensions: 6.9 x 0.5 x 9 inches
• Shipping Weight: 14.1 ounces (View shipping rates and policies)
• Average Customer Review: 3.5 out of 5 stars  See all reviews (25 customer reviews)
• Amazon Best Sellers Rank: #899,375 in Books (See Top 100 in Books)

Most Helpful Customer Reviews

19 of 19 people found the following review helpful

5.0 out of 5 stars You _must_ read it. One of a kind. September 23, 1998

By A Customer

Format:Paperback

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.

11 of 11 people found the following review helpful

5.0 out of 5 stars Best Introduction to Object-Oriented Programming July 4, 1998

By A Customer

Format:Paperback

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.

9 of 9 people found the following review helpful

4.0 out of 5 stars Forces you to think February 21, 1999

By A Customer

Format:Paperback

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.