26 of 28 people found the following review helpful:
5.0 out of 5 stars
A Successful and Worthwhile Book, August 20, 2006
This review is from: Interface Oriented Design: With Patterns (Pragmatic Programmers) (Paperback)
I've been very pleased with Interface Oriented Design by Ken Pugh. Not only does it cover it's stated topic well, but it is also refreshing in two ways: one, at 215 pages it is just the right size for someone who needs an overview of the interface-oriented approach; and two, it operates at a level of abstraction that is paradigm-agnostic and time-proof. This book will be useful and relevant ten or fifteen years from now with only a few minor tweaks in future editions to keep up with the times.
As example of the book's "paradigm-agnostic" approach, while the author does stay fairly rooted in the world of object- and component-oriented development (especially in certain chapters where objects, components, and/or services are explicitly assumed), he is careful to craft the discussion such that it is equally applicable to someone writing a set of web services in Java, a command line utility in C, or a stored procedure in PL/SQL. In doing so, he helps the reader see the commonalites across a variety of situations and approaches. It would have been difficult to achieve this if the author had elected to operate at a lower level of abstraction, diving into detailed code examples right away.
What one reviewer sees as "toy examples" I see as a very successful technique to explain a set of software design principles and techniques without getting caught up in language, platform, and other implementation details. And I do think that the author balances out his less realistic examples by following them up with real-world code and examples. Once the reader has absorbed the principle, he or she can see it at work in a more realistic example. This is a common teaching technique, and I think a very effective one. The author applies it successfully and consistently, both within each chapter and in the overall organization of the book.
It is unfair to say this book does not have realistic examples. The chapters throughout the book discuss both realistic fictional examples (such as an imagined XML pull-parser) and actual real-world examples (such as the refactoring of java.io.inputStream in Chapter 5). What's more, Part III, "Interfaces in the Real World," contains three chapters that each walk through a realistic interface-oriented design, from requirements, through a discussion of design trade-offs, to implementation and testing.
I also don't think it's fair to suggest, as one reviewer does, that this book could be condensed to just two pages. You could say that of just about any book, but more to the point, what I really hear this reviewer saying is, "If you are already an expert in the interface-related topics covered in this book, then it may be too basic for you."
Even if I agreed that the book could be effectively reduced to two pages, thereby removing the need to read it, at most I could see this being true for potential readers who are already experts. If you take a look at the table of contents of this book and consider yourself an expert already in all of the topics covered, then by all means you might prefer a different book. But I still say you'd be missing out.
As for the rest of us, there's a lot to be learned from this book. I started out as a pretty sophisticated reader in this topic area, but I have no doubt I learned from this book and that it will influence in subtle ways my own future software designs. For readers who are unfamiliar with an interface-oriented approach, this book is a great introduction. After you're done with it, you can jump back into that 500 page Java or C# book with a fresh perspective.
This wide-but-not-deep, somewhat abstract approach will no doubt turn off some readers, which is as it should be. It's not a one-size-fits-all world. Some readers might prefer a 400-600 page book with full code for multiple projects, detailed technical discussions, exhaustive consideration of various scenarios, and reference material. Ken Pugh could have written a book more like that, but I'm glad he didn't. I prefer the book we have.
Whether you like this book has probably more to do with your own personal needs, expectations, and stylistic preferences and less to do with whether or not this book is "full of rubbish," which it decidedly is not. The world of software development needs more books like this.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
15 of 16 people found the following review helpful:
4.0 out of 5 stars
good introductory book, September 4, 2006
This review is from: Interface Oriented Design: With Patterns (Pragmatic Programmers) (Paperback)
Too many beginning developers learning object oriented programming dive right into implementation and don't think about interfaces -- and interfaces are what OO is really all about.
This book is a good introduction to designing and thinking about interfaces. It touches on these topics and more, with examples...
The Three Laws of Interfaces:
1. An Interface's Implementation Shall Do What Its Methods Says It Does. (Principle of Least Surprises.)
2. An Interface Implementation Shall Do No Harm.
(implementation should use only those resources suggested
by its interface.)
3. If An Implementation Is Unable to Perform Its
Responsibilities, It Shall Notify Its Caller.
(an error return code or an exception.)
Data interfaces and Service interfaces. Stateless versus Stateful. Cohesion, Coupling, Inheritance, Polymorphism, etc.
This book is succinct, aimed at the novice, tends to be high-level. The reader would be advised to follow up the links and references in the text for more in-depth examples and discussions.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
3 of 3 people found the following review helpful:
5.0 out of 5 stars
VERY VERY HIGHLY RECOMMENDED!!, February 26, 2007
This review is from: Interface Oriented Design: With Patterns (Pragmatic Programmers) (Paperback)
Are you a developer who has some experience with programming and who has been exposed to object-oriented design? If you are, then this book is for you. Author Ken Pugh, has done an outstanding job of writing a book that explores how developing software with an emphasis on interfaces helps you build robust systems easier and faster.
Pugh, begins by looking at some code and textual interfaces. Then, the author looks at how the Three Laws of Interfaces applies to implementations. Next, he explores how to transform an interface from one facet to another. He also looks at different sets of interfaces to explore the concept of cohesiveness. The author then investigates better ways to organize designs using interfaces and delegation. Then, he looks at the ramifications of using remote interfaces. The author continues by showing you how to develop a mini project. Then, he explores interface cohesiveness and generalization. Next, he develops a service registry to explore how directory services work. Finally, the author divides patterns into two camps: class-based and object-based.
In this most excellent book, you'll find techniques for breaking down solutions into interacting interfaces. Perhaps more importantly, this book is all about determining appropriate implementations to create well-structured programs.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
