Customer Reviews

Eclipse Plug-ins (3rd Edition)

5 star:		(19)
4 star:		(12)
3 star:		(3)
2 star:		(3)
1 star:		(1)

 

 

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.

This is a very good book because:

1. It doesn't contain cheap fillers such as JavaDoc References, and repeating things endless etc. For people new to Eclipse chapter 1 gives an introduction to Eclipse: it's very to-the-point.

2. It's very comprehensive. From testing (PDE JUnit) to creating your preferences pages. It's well organized.

3. The length of the code snippets is ok (not too long (filler), not too short). A lot of code is supported by screenshots to explain the code/text.

4. It's just complete!

ONE WARNING: This book covers a pre-release of Eclipse 3.0 and NOT Eclipse 3.1. A reprint of this book is expected in april 2006 (according to the publisher's website). If you can't wait: just buy this book. It's really good. If you can wait wait for the 3.1 edition because some things are changed in Ecllipse 3.1.

I am writing Eclipse plug-ins for almost two years now and owned this book almost from the beginning. Looking back I must say that the book helped me get started and let me believe "it's possible". As probably many others I was a little intimidated at first by the vast possibilities of the framework.
Now that I am much more experienced I must say that whenever I look into the book it leaves me a little bit disappointed. It only adds little value to the "Platform Plug-in Developer Guide" which is part of the online documentation and already covers a lot.
The book goes into details and code very quickly without explaining the concepts very well. I still use the book every now and then for finding some nuggets not covered elsewhere and sometimes I get lucky but not too often.
Shall you buy this book? If you are a beginner and if you like to learn by programming a sample plug-in then yes. The more proficient you get the more the book will lose its value and you will use other sources of information.

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.

If you're planning to write an eclipse plugin, this is THE book to read. The authors have done a fantastic job. Kudos.
Now a few suggestions.
The examples in the book can now be imported in the form of an eclipse plugin. This is great but the examples take a huge leap. For example, chapter 6 introduces you to the concept of views and shows you how to build a simple view with a table and a hard coded set of values. The example in chapter 7 is a huge leap in complexity. It would have been nice to have an example that shows you how to wire events to mouse clicks in the basic "One, Two, Three" view. Instead, the example in chapter 7 tries to do too much. As such, I can only give a limited time to reading the book and going through the examples. The jump in the complexity of the examples from chapter 6 to chapter 7 is like going from "hello world" to socket programming.

Again, my review is based on the perspective of someone who is writing eclipse plugins as productivity tools for my project, not as commercial products that I plan to sell. I may not be the right audience for your fantastic book but I suspect there are a lot of people like me who want to write plugins as productivity tools. Since your book is THE best book on eclipse plugins, I'm sure they'll be referring to it too.

Another thing: Part of the examples from chapter 7 don't seem to work. Specifically, the "add to favorites" button on the toolbar doesn't work because the selection object is of the type TextSelection and not IStructuredSelection. Maybe I'm doing something wrong.

Update: After having actually written a decent eclipse plugin, I have a list of suggestions for people who're just getting started.
1. Eclipse Corner is a very good resource for tips on writing eclipse plugins.
2. If you can't figure out how something is done, try looking for code on google codesearch. For example, lang:java eclipse ASTRewrite
3. If you're using Ganymede, you can see how things are done in the eclipse source code. For example, if you want to see the code that implements the outline view, select the outline view and hit Alt-Shift-F1. This will bring up the plugin spy. It will have a link to the source code that implements the outline view. Of course, the real code for the outline view is buried in a deep hierarchy but you get the general idea.

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.

I read the first edition two years ago and it was the best book at the time on Eclipse 3.0. I learned so much from the first edition, that I got the second edition for Eclipse 3.1 and 3.2 as soon as it was available. I was pleased to see that the authors had completely updated the book to cover the latest versions of Eclipse. All of the negative comments that I see appear to be about the first edition (which is for Eclipse 3.0 and is now out of date) rather than the newer second edition. That really is unfortunate as there is no better book on Eclipse plugin development available. Period.

This book is well organized and very easy to read. It is a very clear and practical guide for how to build and package a complete Eclipse-based product. The book includes dozens of detailed diagrams showing how various elements fit together. Many of the best diagrams were actually printed up in poster form at this year's EclipseCon.

The book goes into great detail on all of the topics necessary to build a "commercial quality plug-in". Some of the material is available on the web, but not nearly in as much detail or with such comprehensive examples. The authors provide dozens and dozens of useful tips and go into detail on various Eclipse best practices such as those required for "Ready for Rational" certification.

All the source code referenced in the book is conveniently available from the book's web site. That makes it easy to try all of the examples without needing to type any of the code in. All of the example code uses pure Eclipse 3.1/3.2 APIs, so there are no deprecated code references (as there would be in the examples from the first edition). The authors have also provided some very useful tools on their web site to make it easier to build plugins. Their free Reference Project tool was particularly invaluable and saved me a tremendous amount of time.

In short, this is an excellent book and I recommend it without reservation. Just make sure to get the second edition and not the older first edition.

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.

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.

With the updates in the second edition, this book has just gotten even more valuable. Not only have the authors updated the material to explain how things work in Eclipse 3.1 and 3.2, but they also provide a heads-up for many possible changes in the future.

If you are relatively new to plug-in development, this book is a must. It covers the most important topics in plug-in development in an easy to follow style. Each topic begins with a description of the basics, then progresses into more complex issues, making it possible to get started quickly, then come back and expand your knowledge as needed. The book as a whole follows the same approach, beginning with an introduction to Eclipse and the plug-in architecture and progressing into individual topics.

If you are an experienced plug-in developer, this book is not only an excellent source of reference material, it also covers many of the issues critical to turning an ordinary plug-in into a first-class plug-in. Discussions range from how to seamlessly integrate with Eclipse to how to make your plug-in extensible and how the Ready for Rational Software requirements impact your design and implementation. It is a must for serious plug-in developers, especially those building commercial applications.

Even if you purchased the first edition, the updates in the second edition make it a valuable reference guide when updating your code to run under Eclipse 3.1 and 3.2. There were a lot of changes in Eclipse and this book will help you make sense of them.