Interface-Oriented Design

by Kenneth Pugh

Interface Oriented Design focuses on an important, but often neglected, aspect of object-oriented design. You'll learn by pragmatic example how to create effective designs composed of interfaces to objects, components and services. You'll see techniques for breaking down solutions into interfaces and then determining appropriate implementation of those interfaces to create a well structured, robust, working program.

Interface Oriented...

• Format: Paperback
• Language: English
• ISBN: 0976694050
• ISBN13: 9780976694052
• Release Date: August 2006
• Publisher: Pragmatic Bookshelf
• Length: 240 Pages
• Weight: 1.10 lbs.
• Dimensions: 0.8" x 7.5" x 9.0"

Customer Reviews

The *WHY* of OO development explained!

This is a lucid explanation of very complex concepts involved in systematic design using interfaces. Chapter 2 on interface contracts was a revelation! We design interfaces and implement them, but what are the expectations between interfaces and their implementation? What covert contracts have to exist between them? As a developer exploring the OOP features of ActionScript 3.0, I really appreciated this book -- don't just use interfaces, figure out why you should use them and how they should be implemented. I had no issues with following the snippets of code, even though there were examples in multiple languages, as the functionality was explained at length. I highly recommend this to any developer, exploring the *why* of OO development irrespective what language they use.

VERY VERY HIGHLY RECOMMENDED!!

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.

Interface-Oriented Design

Very helpful introduction to Interface design. Examples are in C# but easily understandable by a VB programmer.

good introductory book

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.

A Successful and Worthwhile Book

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 a