| | |  | Identity & Access Management | Home » » Practical API Design: Confessions of a Java Framework Architect | | | | | | | Description: | | The definitive guide to API design, this book will be required reading for all designers and engineers involved with the development, testing, and maintenance of APIs. | | | Product Details: | | | Author:
| Jaroslav Tulach | | Hardcover:
| 416 pages | | Publisher:
| Apress | | Publication Date:
| July 29, 2008 | | Language:
| English | | ISBN:
| 1430209739 | | Product Width:
| 1.75 centimeters | | Product Height:
| 2.31 centimeters | | Product Weight:
| 0.02 pounds | | Package Length:
| 10.1 inches | | Package Width:
| 7.3 inches | | Package Height:
| 1.2 inches | | Package Weight:
| 1.9 pounds | | Average Customer Rating:
|  based on 7 reviews |
| | | | Customer Reviews: | |
Average Customer Review:
 ( 7 customer reviews )
Write an online review and share your thoughts with other customers.
Most Helpful Customer Reviews
9 of 10 found the following review helpful:
 As essential to programming as Effective Java by BlochJan 10, 2009
By mathboy
Enough said.
This and Effective Java by Bloch are the two books every Java programmer should have read. It will change the way you program and you'll be grateful for the change. The examples in this book are in Java but that's because they had to be in some language; I don't think any part of this book is specific to Java. If your code is consumed by other people, or even a future self, then this book will help you think through issues you may not have know you have. It did me.
In my opinion, this is those one of those once in a decade books that changes the game for anyone who reads it.
A totally mature, non-didactic work written by someone with that perfect combination of real-world experience, a high intellect, a no BS attitude, and humility.
This book is like getting a magical time telescope- you can see what the decisions you are making in your coding today will actually lead to in the future and what the inescapable consequences will be for you.
Actually, reading this book is a little like being put into the role of Scrooge being visited by the three ghosts of Christmas. You get to see what's going to happen to you because of your past and present actions before it happens. At it's heart it's a longitudinal study of how code is first consumed, abused and misused by other programmers and how those abuses become dependencies which determine what YOU, the code's author can and cannot do in future releases.
In a very small nutshell- totally innocent innocuous, completely legal and even recommended programming practices which you apply every day in your code can and will completely shut down any chance for your code to evolve in any rational way going forward in future releases. Why? Because you can't see the potential consequences of consumers of your code doing something you never thought they might do in ways you never meant for them to do it.
But here's a guy who did do those things and lived to pay the price.
For example, if you think that using interfaces (in Java) is usually the best way to program, then you might have a nasty surprise coming at you when other people (damn them!) actually start to program against your code.
When the book's over, you might be as happy as Scrooge that there's still time to change things before it's too late.
Like Bloch's Effective Java, the lessons in this book are so important that they're destined to become diffused throughout the general programming culture and become known to people who haven't even heard of the book. But can you wait until all that filters down to you through osmosis?
4 of 4 found the following review helpful:
The book I've always been waiting forMar 02, 2009
By David Linsin
Practical API Design: Confessions of a Java Framework Architect is the book I've always been waiting for. Jaroslav Tulach, the founder and architect of NetBeans, created a highly recommend read for everyone in charge of developing APIs.
But even if it's not your job to define interfaces, you are somewhat alway on the other side consuming them and it's good to know what drives evolution of the APIs you work with.
The book consists of 3 parts:
Part 1 is called "Theory and Justification". It defines the terminology and background which gives you the necessary foundation to explain and justify API design.
Let me give you and example: Have you ever had problems explaining your design to a colleague? You couldn't find the right words to reasonably highlight your decision, but you know it was right? The only justification was your intuition and the feeling that your design was the right choice. Does that sound familiar?
That's where Part 1 of this book comes in and tries to give you a tool to justify and even measure the quality of your design decisions: Selective Cluelessness. It's a principle which is based on the assumption that you can achieve more by knowing less:
"The more good APIs we have, the bigger the systems we'll be able to build without understanding all their details."
"Practical Design" is Part 2 and basically puts the theory highlighted in the first part to practice. Using Java, the author provides a set of what he calls API design patterns. They are design patterns in the traditional sense, but with a focus on evolution. Most of them accompanied by an examples the the NetBeans APIs. It doesn't matter if you are not familiar with NetBeans. Due to the author's years of experience with NetBeans, he does a great job explaining the problems it was facing and how they came with a solution, which evolved into an API design pattern.
..., it's slightly more complicated to design a universe than building a house. As a result, we need an enhanced version of the design patters. We need patterns that help us building a "universe".
Part 3 of the book, "Daily Life", is a collection of advices on how to bugfix, evolve and maintain an API. The author points out how important versioning is and how NetBeans solves such a problem. He highlights the importance of compatibility and how to keep the promises to the users of your APIs.
The theory and initial design are just the tip of the iceberg. The rest is the real work.
I'm really glad I read this book, although it took me quite a while. The reason is not the 365 pages. It was all the moments I had during reading it. So many times I was reminded of mistakes I made in APIs I previously designed. I often pondered on whether a solution suggested in the book was better than the one I came up with. I think that's what makes a book interesting, if it makes you think and critically review your own solutions.
I enjoyed taking the journey through the API universe and learning how to design an API in a selective cluelessness way. As for the reasons why you should read this book:
... when you understand the API world, its needs and its laws of evolution, you can shape it into a form containing all that the creators of the oldest and most perfect science always searched for - beauty, truth and elegance. A properly API universe ain't a bad place to be.
2 of 2 found the following review helpful:
Surprisingly Enlightening Top Notch Software Development Book for the Advanced ProfessionalNov 05, 2009
By ws__
Wow! I only wanted to brush up some of my development skills and than this rock of a book. There are problems and solutions I did not have the slightest idea of their existence. I even learned more than in the classic Effective Java (2nd Edition) by Joshua Bloch. The section about concurrency is worth this book alone.
The key part for the PRACTICAL design is part 2. So do not be discouraged from part 1. If you do not like philosophy you might be annoyed, and if you do like philosophy you will be disappointed. A condensed version of the philosophical background of his advice is helpful though: Users of your library should be effective with the maximum amount of cluelessnes. And the development of your library should stay flexible without breaking the code of your clients.
In part 2 and 3 you will find a treasure trove of hard to find advice. Highlights are a very detailed comparison between the tradeoffs of using: interfaces, abstract classes, concrete final classes, ... . You find about problems of offering callbacks to your clients. The ramifications to multithreading are especially interesting. Also of particular interest is his implementation of the visitor pattern that abstracts from the API version of the concrete used library: an example of triple dispatch.
I do strongly support Jaroslav Tulachs call for direct compiler support of versioning of APIs. This immediately helps for solving the great challenges in our open source libraries weaving world.
I do strongly recommend this great book. Thank you Jaroslav.
1 of 1 found the following review helpful:
 Excellent advice from an experienced API designerDec 27, 2009
By Tom Wheeler
Many books explain how to write programs in a given computer language, though books that describe how best to structure those programs are much less common. Practical API Design stands apart from either category in that it teaches how to create the building blocks upon which other developers will base their applications.
The focus of this book is on how you can design software that evolves to meet changing requirements and technology. Although the examples are primarily in Java, the advice in the book transcends any computer language and will be valuable to any developer who creates libraries or frameworks on which others rely. The book describes how to create intuitive APIs, ideas for improving performance through API design, tools for testing compatibility and tricks for compatible evolution.
As the principal designer of the NetBeans Platform (a software framework used by hundreds of organizations, including many Fortune 500 companies), the author certainly knows the topic well. He covers the problems faced when designing APIs, then illustrates them with real-life examples of how to solve them. His thoughtful assessments of what has -- and has not -- been successful for the APIs he has designed allows the reader to benefit from his many years of experience.
In summary, this is an excellent book and I'm not aware of any other which covers these topics with the same depth and passion. I've given it four stars for only one reason: it could be more concise. It sometimes embarks on tangents which, while interesting, don't seem to reinforce the main points.
Full disclosure: I'm an active NetBeans Platform developer and I know the author personally. At his request, I served as a technical reviewer for the manuscript of this book. Although the publisher sent me a free copy of the book following publication, I received no other compensation and feel that the review I've given here is honest and unbiased.
a must-readMay 14, 2011
By Michael Huettermann
If you are busy with or interested in API design, you should read this book. This book delivers many valuable practices, together with philosophical sections. It's easy as well as enjoyable to read. This book should be accompanied with books that deal with design patterns and code quality. Summary: clear recommendation and a must-read!
See all 7 customer reviews on Amazon.com
| | |
|
