Contributing To Eclipse: Principles, Patterns, And Plug-Ins

Yes, this book is definitly worth it’s price. I’m used to have it lying beside my keyboard while coding plugins. Even after a long time of coding in Eclipse you’ll see your self spending some time and learning about some special concepts from Eclipse. There are not so much codesections that could be copy&pasted, but they will show you how to gather your information yourself, without long and ugly examples.
The TestDrivenDevelopment was very new to me and so I had my problems extracting some details from the code. There are some Graphs created with their own tool called Spider which I found also not to be that useful.

Guess the only negative review on here established that you probably shouldn’t buy this book if you consider yourself an expert on the subject. I’m usually sympathetic to criticism of books that claim that the examples are too simple (very common, showstopping problem with MANY books), but in this case, I think the balance that is struck is just about perfect. You can follow what is being done in the code while reading along, and the code actually does stuff that is useful.
The real reason this book deserves 5 stars is, the secret is that this book is actually 4 or 5 books in one, and it’s also perhaps one of the best practical guides to the future of programming. Consider:
1. Just the unit testing aspects of this book are better than in many books that are just about unit testing.
2. Framework programming is a really dimly lit subject. The only frameworks most people have any experience with are UI frameworks. Eclipse is a great example of a comprehensive framework, given the fact that all things are done as extensions. Just that aspect of this book is a hugely important lesson to be gleaned. The literal expert will say they already knew how to do each step; the structuralists in the crowd know that a big part of successful pedagogy is having people experience the making of something (in the same way that cookbooks are a fusion of things to learn about technique, not just a collection of specific recipes).
3. The pattern discussion is good and benefits from its situation in the broader framework context. (Checkout the Junit Cook’s Tour article by the same authors; it is one of the best short works on patterns around.)
The only knock on this book is that it’s about Eclipse 2.x. At Eclipsecon a couple weeks ago, almost the whole room raised their hands during a straw poll about how many were using 3.x. Because of the above, this book is still worth it. Would have been nice if someone updated the code to compile with 3.x though.

Two widely know and experienced software authors came together to produce this book. Their writing skill shows clearly in the clarity of the step-by-step pedagogy that they use. They define a “Contribution Circle” of different types of Eclipse usage, from User to Configurer to Extender to Publisher to Enabler and back to User. They suggest how each role can get code from its predecessor, add to it or extract ideas for a new code base, and then offer these new changes to its successor. In doing so, we see the emergence of a virtuous positive feedback loop, and the rise of an Eclipse community.
Granted, this may sound nice but vague. So Gamma and Beck proceed in the book to describe 4 such circles, in gradually increasing detail, that illustrate the concept. As is obligatory in a software text, they start with the demotic “Hello World”. The coding is trivial. But even here, they show the various needed files and a look at the Eclipse framework. Plus, and this is good teaching style, most readers will gain some understanding immediately from this first example. Encourages you to delve further. (As opposed to a text that is totally over most readers’ heads from the first chapter.)
The book gives the big picture of Eclipse, in explaining the various roles of users. As such, it is a good complement to other Eclipse texts, which tend to focus on specific Eclipse features or applications.