Rating: 
Summary: Serious advice for the serious developer
Review: As the title suggests, this massive tome is intended as a guide to best practices for writing Eclipse plug-ins. I think in that respect it succeeds handily.
If you've been living in a hole: Eclipse is a phenomenally successful, infinitely extensible open-source Java IDE. By many estimates, 60% or more of Java developers are using it. Not everyone realizes that Eclipse has a big brother: IBM's commercial WebSphere Application Developer (WSAD) is a branded version of Eclipse bundled with an enormous range of add-ons (or "plug-ins", as they're more properly called.) IBM maintains a certification program, the "Ready For WebSphere" (RFWS) label, which involves meeting a suite of requirements and tests aimed at making an Eclipse plug-in into a best-of-breed tool that works well in the WSAD environment.
In a methodical, workmanlike way, Clayberg and Rubel wend their way through the components of a professionally-produced plug-in, with an eye towards qualifying for the RWFS certification. There is no fat to be trimmed here. Instead, this book focuses on enumerating everything from the solid underpinnings to the little touches that make a plug-in into a dependable, useable tool.
The book includes many screen shots and some very nice UML diagrams. It's nicely up to date, as the step-by-step instructions and screen shots pertain to the recently-released Eclipse version 3.0 .
Before you even think about distributing a plug-in you've written, read this book.
Rating: 
Summary: Before you start developing your plug-in -- read this
Review: I bought this book and it has been a tremendous help for me in developing an Eclipse plug-in at my work. I am new to Eclipse much less developing plug-ins for it; but this book goes step by step with plenty of examples. I like how the authors shared various tips and techniques to help you save time. The book is nicely details on all aspect of Eclipse workbench, wizards, views, and perspectives. It has everything that I need to get started on developing plug-ins. I wish I had this book before I started researching about this topic on my own with the Eclipse help files. Use this book as a references or your guide - just use it. It saved me at least two weeks of trying to research it on my own. The other part that I like about this book, is that, it dives directly into the topic with necessary details and examples; rather than sugar coat it with boring information that will make you get another cup of coffee before you start coding. You can litterally pick up this book and start coding your plug-ins.
Also, the author developed some useful tools to help you with your plugins, such as, the "SWT Spy" and "Part Info View" tools. I wouldn't even know where I can get these type of information without these tools.
Rating: 
Summary: Great topic, reasonable book
Review: I want to love this book but I can't. The topic is really great. But the book itself relies too much on screenshots and code fragments to carry the weight of the topic. That's a great way to present information, but not a great way to teach the topic. The text is adequate to hold it all together, but frankly I think the topic deserves a little more. I think this is the only book out there on the topic, and it's good enough to get you through. So if you are actively looking to build a plugin you may want to stop by your local bookstore to give this a look see.
Rating:
Summary: Excellent Book on Eclipse
Review: I was looking for a good book to learn about Eclipse to get our NineSYNC product to be ported into the Eclipse platform. This book helped us extensively to port the product to Eclipse. The book is very clearly explained and covers almost every practical aspects of Eclipse. After reading this book you can create commercial quality plugin with confidence just as the book states. One only topic this book is missing is about RCP (Rich Client Platform), which allows creation of independent applications. But the eclipse.org site already contains the required sample applications to get it started.
Ejaz Jamil, Jence Incorporated, http://www.ninestep.com
Rating:
Summary: The Best Book Available on Developing for Eclipse
Review: If you own any book about Eclipse, but not this one, you're insane. It is, by far, the best available for plug-in designers and developers.The style of the book is perfect. It walks you through the creation of a relatively simple, yet extremely thorough plug-in. Along the way, you get a comprehensive summary of how to utilize just about every facility that Eclipse provides. The code examples are explained with illuminating elegance. ("Ureka! Now I understand all of this!") Rich with screenshot examples. A wealth of tips on use of the IDE itself including fresh insight into version 3.0. Can a person actually have fun with a technical reference? My copy (only a week old) is already ratted, dog-eared, and soiled with coffee stains. Now, I feel like an Eclipse guru. I never write book reviews, but felt compelled to assure my fellow geeks that this one is a solid investment. It is the definitive "Master's Handbook" for the software world's coolest tool.
Rating:
Summary: must have
Review: Looking for a book to start with using Eclipse and writing plug-in for the Eclipse platform,this is a must read book. The book is up to date with the software, easy to understand, and much more. I highly recommend this book to anyone would like to get involved with Eclipse.
Rating:
Summary: Detailed and comprehensive
Review: This book is the better one I have found for learning about plugin development for Eclipse. Most books present a very simple example which fails given the scope of Eclipse and the multitude of extension points. This one doesn't. It tries to address all the things that you may want to do (put an action in different places, integrating with different resource types (files,etc) and existing views (editors,etc), saving, UI, UI decoration, and on and on).
It takes a project and puts it through a complete development cycle building and adding features through the book. While I typically don't like books that take a single example and develop it throughout, this has enough meat to make it very useful. Sections that introduce different concepts/areas, will also give you extension points/view names for those areas so I can see the book as a valuable reference after the initial read.
One very cool thing with the sample project is that the authors develop JUnit tests for the UI actions and things. This shows not only how to automate testing of the UI features, but how eclipse calls your plugins. This provides additional insight that is useful not only in testing, but also in feature development. As it shows you how to load/find certain things programmatically.
If you use books as a tutorial from end-to-end, and tend to type over the examples to build mechanical memory of code, you may run into a few small snags. Chapter 7 misses listing some of the classes you are going to need (minor types, which you can figure out), and some minor disagreements in the code will create errors in the project, but these are easy to fix.
The code style is OK, but could be more concise and streamlined at times.
I would have given the book 5 stars if it wasn't because the book was developed under a pre-release of Eclipse 3.0. This made for some of the screen shots to be inconsistent, and very few of the api calls used in the examples are deprecated. This is more for Addison-Wesley than for the authors. Publishers always want to release books early, and this is hard on both writers (writing against a changing target) and the readers getting something that doesn't match the actual product.
Rating:
Summary: Lots of good information
Review: This is a good book about writing Eclipse plug-ins, but it's four-star good, not five-star good. The reason it earns only four stars from me is that although this book sets out to be a "how to" tutorial for building plug-ins, it ends up being more of a reference book because it is missing a checklist or flowchart of "steps to take to build a commercial quality plug-in". I expected to find a simple set of rules, checklists, flowcharts, etc. at the beginning of each chapter that would lead me through the choices and implementations. Take as an arbitrary example, chapter 12 "Preference Pages" - I realize that the experienced app developer will already know that all hard-coded magic values should be replaced by preferences, but this book is aimed at the less experienced devs as well. I guess what I was expecting was the Ready for Websphere guidelines combined with a how-to section for implementing each those guidelines.
However, having complained about the disconnect between my expectation and the reality, I'll point out that I did give the book four stars. This book is dense with material and examples. I consider myself a reasonably knowledgeable plug-in dev and yet I learned things that I had not previously known (in my case: builders, fragments, infopops, ...). Additionally, the authors share their knowledge of the best way to accomplish certain tasks: for example, the best additional plug-ins to use and even some special plug-ins they themselves wrote for developing plug-ins. The one I find most useful this week is the "find part identifiers" plug-in described in section 20.6; very useful - I don't understand why it wasn't part of the original Eclipse platform.
This book has been placed onto my reference shelf within easy reach of my keyboard. Four stars.
Rating:
Summary: great book for serious Eclipse developers
Review: This is a great book for serious Eclipse developers. I saw these guys speak at an Eclipse gathering in Portland last November, and when I heard they were writing a book I immediately lobbied to be an official reviewer. (I wanted to know what they knew as fast as possible...) The online resource for this book at qualityeclipse.com is also a useful source for Eclipse tools and information.
Rating:
Summary: This is a great book!
Review: This is easily one of the most useful books I own. If you are new to developing Eclipse plugins, it is a "Must Have" that will save you LOTS of time and effort. If you have already read everything available at eclipse.org and IBM develperworks, you will still find lots of new topics and good advice in here, especially things that will help add a whole layer of professionalism and completeness to any plugin.
The book is very focused, well structured, thorough, clearly written, and doesn't contain a single page of "waffly page filler". Granted, as one reviewer says, some of the code and screenshots are a little out of date, however I've found it very easy to get everything to work as I've gone through the examples. The "Errata" page at qualityeclipse.com is also a useful resource and seems to be actively maintained.
The style of the book is very tutorial and "doing" focused, but there are very good descriptions of why everything is the way it is...not just empty instructions to "click here" and "type this" like some other books I've come across. They also cover alternative ways to achieving something (not just explanations, but code too) and explain which would be more useful in different situations.
As someone else mentioned, the diagrams explaining the relationships between the different components and manifest sections are excellent, and aid in understanding how everything fits together. It really helps to be able to look at a diagram with all the pieces connected by relationships while designing and coding. I haven't seen anything like this in any of the material found online.
This book goes well beyond Actions, Views, and Editors, and I think everyone will benefit from the authors' experience. I certainly have :-)
|
