無料のKindleアプリをダウンロードして、スマートフォン、タブレット、またはコンピューターで今すぐKindle本を読むことができます。Kindleデバイスは必要ありません。
ウェブ版Kindleなら、お使いのブラウザですぐにお読みいただけます。
携帯電話のカメラを使用する - 以下のコードをスキャンし、Kindleアプリをダウンロードしてください。
Interface Oriented Design: With Patterns (Pragmatic Programmers) ペーパーバック – 2006/7/24
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ページ
- 言語英語
- 出版社Pragmatic Bookshelf
- 発売日2006/7/24
- 寸法19.05 x 2.16 x 22.86 cm
- ISBN-100976694050
- ISBN-13978-0976694052
商品の説明
著者について
登録情報
- 出版社 : Pragmatic Bookshelf; 第1版 (2006/7/24)
- 発売日 : 2006/7/24
- 言語 : 英語
- ペーパーバック : 240ページ
- ISBN-10 : 0976694050
- ISBN-13 : 978-0976694052
- 寸法 : 19.05 x 2.16 x 22.86 cm
- カスタマーレビュー:
著者について
著者の本をもっと発見したり、よく似た著者を見つけたり、著者のブログを読んだりしましょう
カスタマーレビュー
私たちの目標は、すべてのレビューを信頼性の高い、有益なものにすることです。だからこそ、私たちはテクノロジーと人間の調査員の両方を活用して、お客様が偽のレビューを見る前にブロックしています。 詳細はこちら
コミュニティガイドラインに違反するAmazonアカウントはブロックされます。また、レビューを購入した出品者をブロックし、そのようなレビューを投稿した当事者に対して法的措置を取ります。 報告方法について学ぶ
他の国からのトップレビュー
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.
Having said that, it does a good job of explaining the topics it covers. Anyone who hasn't spent years writing OO software would benefit from it.
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.