Programming Books C Java PHP Python Learn more Browse Programming Books
Buy New
$19.48
Qty:1
  • List Price: $29.95
  • Save: $10.47 (35%)
FREE Shipping on orders over $35.
Only 10 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Interface Oriented Design: With Patterns (Pragmatic Programmers) Paperback – July 24, 2006

ISBN-13: 978-0976694052 ISBN-10: 0976694050 Edition: 1st

Buy New
Price: $19.48
29 New from $14.16 31 Used from $0.01
Amazon Price New from Used from
Paperback
"Please retry"
$19.48
$14.16 $0.01

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



Frequently Bought Together

Interface Oriented Design: With Patterns (Pragmatic Programmers) + The Pragmatic Programmer: From Journeyman to Master + Clean Code: A Handbook of Agile Software Craftsmanship
Price for all three: $96.26

Buy the selected items together

NO_CONTENT_IN_FEATURE

Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Product Details

  • Series: Pragmatic Programmers
  • Paperback: 240 pages
  • Publisher: Pragmatic Bookshelf; 1 edition (July 24, 2006)
  • Language: English
  • ISBN-10: 0976694050
  • ISBN-13: 978-0976694052
  • Product Dimensions: 9.1 x 7.5 x 0.8 inches
  • Shipping Weight: 1 pounds (View shipping rates and policies)
  • Average Customer Review: 3.8 out of 5 stars  See all reviews (9 customer reviews)
  • Amazon Best Sellers Rank: #1,299,319 in Books (See Top 100 in Books)

Editorial Reviews

About the Author

Ken Pugh has extensive experience in the area of software analysis and design, both as a doer and as a teacher. He's a well-known, frequent conference speaker.


More About the Author

I'm a principal consultant with Pugh-Killeen Associates Isince 1982). My professional interests are development processes (especially agile ones), object-oriented design, and security. I've been involved with projects ranging from satellite tracking to goat serum process control to stock portfolio analysis. I'm ambidexterous - developing for both Windows and UNIX/Linux.

Customer Reviews

3.8 out of 5 stars
Share your thoughts with other customers

Most Helpful Customer Reviews

26 of 28 people found the following review helpful By D. Read on August 20, 2006
Format: Paperback 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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
15 of 16 people found the following review helpful By C. K. Ray on September 4, 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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
13 of 18 people found the following review helpful By Thing with a hook on August 13, 2006
Format: Paperback
This book discusses and encourages thinking about object oriented design in terms of interfaces, i.e. the high-level "tasks" that an object offers to carry out for you, rather than thinking about implementation details. Examples are given in a mixture of languages (not all OO), with the majority in the Java-like notation Pugh used in his previous book, Prefactoring. There are three parts to the book. The first part, which takes up the first half of the book, introduces interfaces and discusses them in the context of contracts, stateless versus stateful, and the interplay of inheritance and interfaces. The second part consists of one chapter on an agile development process, which discusses use cases and CRC cards (here redubbed Interface Responsibility Interaction cards). The third part covers three examples, and then a final chapter on design patterns.

The author suggests that the target audience for this book are those developers who have been "exposed to object-oriented design". However, I find it hard to believe that a beginner programmer will not have been introduced to the main thrust of the discussion in any introductory book on Java. An intermediate developer will have much of this material covered in a book on Design Patterns, or in any book that discusses the maxim 'favour composition over inheritance'.

My problem with this book is that while a fairly large number of topics are covered, it's all very superficial. Advantages and disadvantages of various approaches are summarised, but they're not very helpful, e.g. an advantage of a stateless interface is "order of the method calls does not matter", versus a stateful interface: "parameter lists shorter".
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 2 people found the following review helpful By devxlr8 on August 31, 2007
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Search

What Other Items Do Customers Buy After Viewing This Item?