Contributing to Eclipse: Principles, Patterns, and Plug-Ins

by Erich Gamma and Kent Beck

Book Overview

Even long-time Eclipse committers will be surprised by the breadth and depth of this book. A must-read for every new Eclipse extender.--Andre Weinand, Eclipse Committer Contributing to Eclipse offersA... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0321205758
• ISBN13: 9780321205759
• Release Date: January 2003
• Publisher: Addison-Wesley Professional
• Length: 395 Pages
• Weight: 1.80 lbs.
• Dimensions: 0.9" x 7.0" x 9.4"

Customer Reviews

Different is good

"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.

Zen and the Art of Eclipse

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.

The Big Picture of Eclipse

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.

Excellent tutorial and guide...

ReviewAs 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. ConclusionThis 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.

A great resource for anyone that wants to extend Eclipse

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.