- Jubilee offer: spend £10 or more on any product sold by Amazon.co.uk on or before June 6 and you can buy The Diamond Jubilee A Classical Celebration Album for just £2.50 Here's how (terms and conditions apply)
Did you know you can trade in your old books for an Amazon.co.uk Gift Card to spend on the things you want? Plus, get an extra £5 Gift Certificate when you trade in books worth £10 or more before June 30, 2012. Visit the Books Trade-In Store for more details. |
Special Offers and Product Promotions
Product details
|
More About the Author
Product Description
Product Description
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.
From the Publisher
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.
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
Customer Reviews
Most Helpful Customer Reviews
1 of 1 people found the following review helpful
Format:Paperback|Amazon Verified Purchase
A rather pedestrian trawl through the essentials of programming interfaces. Saved by a couple of better than average case studies in second half. The material is all there, but the book is not inspiring writing.
Format:Paperback
This is really an introductory level text on design, based on the Class-Responsibility-Collaboration framework, but updated, by thinking about interfaces instead of classes, and by putting more emphasis on testing. The author states, for instance, that "Writing tests for an interface can also help you work out difficulties in the interface... If you find that your interface is hard to test, then it probably will be hard to use". (I still think this is introductory level, but the preface does suggest that readers should have been exposed to O-O).
Like a lot of other texts in the Pragmatic Programmers series, it is a very easy read, and doesn't go into a great deal of depth - you don't feel full after consuming it. It doesn't cover all the points in Joshua Bloch's "How to Design a Good API and Why it Matters", but there is a reasonable amount of good advice in it all the same, and he isn't talking to the same audience. In this book, published APIs you are committed to support are a described as a sub-topic, and the emphasis is on using internal interfaces to structure small-medium projects - perhaps half a dozen people.
This book is largely language-independent and even considers serial interfaces as interfaces. Bloch, for example, is very keen on being language specific to reuse the idioms and conventions of a particular language to maximum effect. I like the idea of learning an approach that I can carry over to whatever language the customer picks for me, but I suspect that applying a final language-specific polish to a design would be a good idea.
Like a lot of other texts in the Pragmatic Programmers series, it is a very easy read, and doesn't go into a great deal of depth - you don't feel full after consuming it. It doesn't cover all the points in Joshua Bloch's "How to Design a Good API and Why it Matters", but there is a reasonable amount of good advice in it all the same, and he isn't talking to the same audience. In this book, published APIs you are committed to support are a described as a sub-topic, and the emphasis is on using internal interfaces to structure small-medium projects - perhaps half a dozen people.
This book is largely language-independent and even considers serial interfaces as interfaces. Bloch, for example, is very keen on being language specific to reuse the idioms and conventions of a particular language to maximum effect. I like the idea of learning an approach that I can carry over to whatever language the customer picks for me, but I suspect that applying a final language-specific polish to a design would be a good idea.
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
11 reviews
26 of 28 people found the following review helpful
A Successful and Worthwhile Book
20 Aug 2006
Format:Paperback|Amazon Verified Purchase
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.
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.
15 of 16 people found the following review helpful
good introductory book
4 Sep 2006
Format: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.
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.
3 of 3 people found the following review helpful
VERY VERY HIGHLY RECOMMENDED!!
26 Feb 2007
Format: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.
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.
Were these reviews helpful?
Let us know
Listmania!
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
|
