Rating: 
Summary: Different is good
Review: "Contributing to Eclipse" is a great read. More importantly, as someone who is in the middle of their first major Eclipse plugin development project, I learned a lot -- even though I've previously read every other available book on the topic. Gamma and Beck take you through the development of a fairly sophisticated plugin, step by step. Perhaps most welcome, the plugin they develop isn't a syntax-highlighting text editor (an example that's already been done to death,) but a set of tools for running JUnit tests on Java code!
This is the only book I've seen that discusses testing and Test-Driven Development of plugins, a must for serious plugin developers. As you'd expect from the developers of JUnit, they use JUnit to test every piece of functionality they add. Surprisingly, even though you'd expect some confusing in writing about using JUnit to test a JUnit plugin, there's none. Gamma and Beck are both excellent writers, and they know this subject matter inside out.
A word of warning: this is neither an introduction to nor a reference for Eclipse plugin programming. I don't think I would have gotten nearly as much from this book if I hadn't read "Eclipse in Action" and "The Java Programmer's Guide to Eclipse" first. But if you've gotten beyond the novice level with Eclipse, I guarantee you'll learn something by reading this book.
Rating: 
Summary: Feels like a first draft
Review: Big name authors, but the book really doesn't deliver.The authors take the approach of guiding the reader through 3 "circles" of eclipse development. This reasonable pedagogical approach is underminded by frequent errors and unexplained changes/additions to the code being developed. Circles 0 and 1 take the reader through the canonical "Hello World" example followed by a more substantial example Test plugin. Circle 1 is particularly let down by various unexplained additions to the code being developed. Additionally, complex code approaches are adopted which hinder the explaination of the task at hand. Throughout these circles, various interesting but unnecessary sidebars meander through justifications for why the Eclipse way is "Right"[tm]. These sidebars are poorly placed and delve far into the philosophy behind Eclipse. The content of these sidebars is interesting, however the diversions only serve to muddy the waters at a point where the reader is mostly interested in learning how to write a plugin. (As opposed to becoming a member of the Eclipse cult.) Circle 2 continues with the development of the test plugin started in circle 1, expanding functionality and exposing the reader to further aspects of plugin development. Finally, circle 3 takes a higher level look at appropriate patterns for plugin development. This is the place where the earlier philosophy and detailed information scattered in circles 0 and 1 would have best been presented. (That is after the reader has a grasp of the terminology and has got enough speed up for the information to be useful.) Overall, the writing is reasonable but tends towards sloppy in places. In a sense the writing feels like it needs some quality time with a good editor.
Rating:
Summary: A great resource for anyone that wants to extend Eclipse
Review: Eclipse is the name of both an open source IDE and the extensible framework that it is built upon. A little experience of using Eclipse as an IDE, and a desire to extend the framework further are needed for this book. Before you know it, you'll be developing your first plug-in. Of course, it's a 'Hello World', but it introduces the concepts you need to go on to bigger and better things. The 'bigger and better' thing the book provides is a JUnit plug-in that performs automatic unit tests during builds. The authors don't just teach you how to build a plug-in, but how to build a plug-in that 'plays well with others' and allows for your plug-in to be extended in the future. Wrapping up the book are a collection of 'pattern stories' describing some of the design patterns used in Eclipse. The clear writing style and the flow of topics will help you get up to speed and writing plug-ins in no time. If you need further details on a topic ample references to the Eclipse documentation or other books that will help you on the subject are provided. All-in-all this book is a great resource for anyone that wants to extend the functionality of Eclipse.
Rating:
Summary: Lots to Offer
Review: 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.
Rating: 
Summary: What I would expect if there was NO docs for eclipse
Review: I don't like this book as a book on writing plugins for eclipse for the following reasons:
1) This book's 'exploratory' approach tries to show you how to search (the hack approach) through the installed plugins for excerpts that you can copy/paste/edit. It would have been more useful if the authors used a 'tutorial' approach that constrains the example to documented basics (many different examples that then integrate/or not).
2) As expected (and tiring if you have other book from these authors), JUnit integration is the example developed throughout the book. This may satisfy the need for some types of plugins (code oriented plugins), but leaves much to be desired if you want to develop other kinds of tools.
3) The samples are outdated in 3.0, and the main example won't work/run in 3.0 (even if you download their project source). If you try to follow along, you will quickly be disapointed once you run into that snag. I am sure that under 2.x it works great.
4) This book is useful as a way of seeing a small example built up. However, because of #3, this all becomes useless once the plugin doesn't 'work'.
As with most books that cook a long example as a way of teaching, rather than as a way to support other knowledge, much of the time is spent on explaining how to cook things for the example. For me this doesn't work, as I want something focused that instructs me, rather than a evolving code-walkthrough of a particular example. To me this is boring, and has no use after the initial read.
This book would be great if it was 1/2 as long, and focused on the patterns for the plugins instead, not presume to be an intro to plugin development.
Rating:
Summary: beginners guide only
Review: I just received my copy, expecting a pound of deep revelations about the philosophy and architecture of eclipse, which could also benefit a rather experienced plugin developer like I consider myself. After all, the illustrous names on the front cover seemed to justify the expectation that this was not a "plugin programming in 3 days" course. However, the book I held in hands was of the kind that could easily be condensed to booklet format if a lesser generous layout and was used. The numerous screenshots contribute their part, although the volume is still rather moderate. In the end, my conclusion is that this book may have been put together in a similar manner as described on the back of the cover: "Erich and Kent enjoy programming together while glacier hopping high in the swiss alps". Let me add that this review is mainly from the standpoint of a fairly experienced plugin programmer, and it is from that standpoint that I only rate it one star. The situation may be different for someone who needs a brief introduction to get going in this field.
Rating:
Summary: Ego Gratification
Review: I'm sorry but this book seems to be more about gratifying the authors' egos than actually helping anyone contribute a development tool to eclipse. As a previous reviewer indicated there is a CULT feel to the whole business. Page 2 shows the pyramid of enlightenment. One can imagine Gamma and Beck sitting on the point. Of course there's money to be made in such cults and I suspect some of the "rave reviewers" are trying to cash in. However, eclipse itself is not so bad and the on-line documentation (as opposed to this book) is actually useful. I particularly recommend the articles by John Arthorne. I'm sorry about giving such a negative review but I think it's important to discourage this kind of "cultism."
Rating:
Summary: Zen and the Art of Eclipse
Review: Once you get past the interesting writing style, this is a pretty cool book written by two of the giants in the industry. This is a particularly good book, if you are interested in Eclipse plugin development and JUnit testing. The tutorial is pretty comprehensive and the book example evolves in a natural way. The only downside is that this book is targeted at Eclipse 2.1 rather than 3.0 (which is no wonder given that it predates 3.0 by more than six months). This doesn't really detract from the book because most of the examples are fairly generic and can be made to run in Eclipse 3.0 with minimal effort.
Rating:
Summary: Excellent tutorial and guide...
Review: Review
As I move more into the world of Java and Websphere development, I'm spending more and more time in the Websphere Studio Application Developer (WSAD) IDE. This is built on the open source Eclipse framework and allows you great flexibility in extending the package to include tools that you write and incorporate into your workspace. But while it may be possible for you to write your own tools, you'll need to have a good resource to guide you through the process. This is the book to do that. Erich Gamma is well known as one of the "Gang Of Four" who wrote the classic Design Patterns book. Kent Beck is the father of Extreme Programming. Given the pedigree of these two authors, you know that there will be plenty of proper programming techniques and concepts that underlie each chapter. They also stress that to properly build tools for Eclipse, you have to understand the platform and work with it. They spare no effort in making sure that understanding is present each step of the way. The book works through a sample plug-in to help you run JUnit tests on your code. The style closely follows an Extreme Programming type development cycle. The basic functionality is built and tested, and then more comprehensive features are added. By the time you finish the book, you should be well on your way to understanding tool writing for both your own work or for possible product sale. IBM has concentrated on the Eclipse platform for the development of a rich client that can run web applications. Because of the extensible nature of Eclipse, this could lead to multiple opportunities for add-on features that could easily be integrated into the new client. By using the concepts in this book, you can put yourself ahead of the curve as IBM moves forward in the Lotus area. Conclusion
This is an excellent book if you are looking to build tools (for yourself or others) for either Eclipse or WSAD. Very readable and filled with essential knowledge you need for this type of development.
Rating:
Summary: Excelent Book about Eclipse contribution
Review: This book is Excelent. It is written in a clear way, with a very accesible language and excelent examples that get you going, in just a matter of hours, into writing full Eclipse plugins. The authors teach every lesson with perfect examples and pointers to the Eclipse platform. This book is great not only for learning how to contribute to Eclipse, but also for learning Eclipse itself! It could very well be a book about "Learning Eclipse by writing plug-ins". This book is an excelent guide and a reference all Eclipse developer shoould have.
| 
