What do you think?
Rate this book
Interface Oriented Design
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 Design explores how to develop robust, reliable software as a collection of interfaces that interact with each other.
You'll learn what polymorphism and encapsulation really mean, and how to use these ideas more effectively. See how to create better interfaces using agile development techniques, and learn the subtle differences between implementing an interface and inheriting an implementation. Take a fresh, modern view of Design By Contract and class responsibilities. Understand the basis of a service-oriented architecture, including stateful versus stateless interfaces, procedural versus document models, and synchronous versus asynchronous invocations.
Learn about the most useful patterns, including Proxy, Facade, Adapter, and Factory, as well categories of interfaces including service providers, information holders, and external world interfaces.
If you want to be a more effective programmer and create better software, you need Interface Oriented Design.
240 pages, Paperback
First published January 1, 2006
8 people are currently reading
81 people want to read
About the author
Ken Pugh
20Ìýbooks1ÌýfollowerA principal consultant with Pugh-Killeen Associates since 1982). His professional interests are development processes (especially agile ones), object-oriented design, and security. He has been involved with projects ranging from satellite tracking to goat serum process control to stock portfolio analysis. He's ambidexterous - developing for both Windows and UNIX/Linux.
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 4 of 4 reviews
April 2, 2014
This is a FANTASTIC book. But it doesn't seem that way when you first start reading it. The beginning conceptual chapters are rather basic, though I suspect that many of the blase reviews are written by people with many years in the field who don't get maximum value out of them. The first 2 sections are actually optimal for developers just out of school/just beginning to write "enterprise grade systems" within their first 6-18 months. For people with more experience, it will be mostly review...though the sections on stateful versus stateless interface design are interesting.
Where this book really shines, however, is the "Interfaces in the Real World" section. The systems built have been described by some reviewers as "toys"...and yet I've found myself implementing some version of a "WebConglomerator" or "Link analyzer" in company settings since 2006. I'm actually implementing a glorified Service Registry right now that has absolutely stymied some of my colleagues to design...and this book makes it look ridiculously easy.
What makes these examples truly compelling, however, is that they are CLEAN. These designs are FANTASTIC. If you really know how to think in interfaces, it becomes obvious to you how you can design these systems using TDD/BDD and implement in such ways that it's easy to switch from a Gson-based parser to Jackson, XML to YAML, etc etc. These are actually fantastic case studies in how to build frameworks masquerading as toy problems.
The last chapter on Design Patterns is succinct, but far more interesting than superficially thought. Encapsulating native collections with your own types is something developers everywhere just don't do enough of, and the benefits become fantastically clear with the BUILDER-esque chaining implementing AND and "merge" implementing OR criteria. I had never even thought of something like that. The treatment of FACTORY METHOD and discussion of PROXY vs. DECORATOR does a nice job of showing different options, and reinforcing the differences between the intents in the patterns.
...basically, anyone trying to be a Real Software Architect should read this short book on a Saturday morning, then think hard about it. It's got a lot of great content, in a very digestible and well-written format.
Where this book really shines, however, is the "Interfaces in the Real World" section. The systems built have been described by some reviewers as "toys"...and yet I've found myself implementing some version of a "WebConglomerator" or "Link analyzer" in company settings since 2006. I'm actually implementing a glorified Service Registry right now that has absolutely stymied some of my colleagues to design...and this book makes it look ridiculously easy.
What makes these examples truly compelling, however, is that they are CLEAN. These designs are FANTASTIC. If you really know how to think in interfaces, it becomes obvious to you how you can design these systems using TDD/BDD and implement in such ways that it's easy to switch from a Gson-based parser to Jackson, XML to YAML, etc etc. These are actually fantastic case studies in how to build frameworks masquerading as toy problems.
The last chapter on Design Patterns is succinct, but far more interesting than superficially thought. Encapsulating native collections with your own types is something developers everywhere just don't do enough of, and the benefits become fantastically clear with the BUILDER-esque chaining implementing AND and "merge" implementing OR criteria. I had never even thought of something like that. The treatment of FACTORY METHOD and discussion of PROXY vs. DECORATOR does a nice job of showing different options, and reinforcing the differences between the intents in the patterns.
...basically, anyone trying to be a Real Software Architect should read this short book on a Saturday morning, then think hard about it. It's got a lot of great content, in a very digestible and well-written format.
September 18, 2021
A little dated, in terms of specific implementation technologies (CORBA, anyone?), which should be expected for a tech book published back in 2007, but the principles are still perfectly applicable to the development challenges of 2021.
In fact, instead of being a distraction, I would say that seeing the mapping of these principles to earlier technology implementations is actually helpful, in the sense that it really points out that the high-level concepts can outlive the implementation choices of a given time period.
In fact, instead of being a distraction, I would say that seeing the mapping of these principles to earlier technology implementations is actually helpful, in the sense that it really points out that the high-level concepts can outlive the implementation choices of a given time period.
June 9, 2014
The book explores different ideas on how to structure your code. While some chapters are interesting, the information provided is repetitive and there are parts that are irrelevant. I'll definitely go back to some parts of this book that provide good advice but i won't read it again or recommend to anyone.
November 26, 2012
The book didn't really teach me anything I didn't already know. In fact, I'm not sure how well it would have taught me had I not already understood all the concepts beforehand.
Displaying 1 - 4 of 4 reviews
Can't find what you're looking for?
Get help and learn more about the design.