Home > Store > Programming > Java

larger cover

Add To My Wish List

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

Register your product to gain access to bonus material or receive a coupon.

  • Description
  • Downloads
  • Extras
  • Reviews
  • Sample Content

Product Author Bios

Kent Beck consistently challenges software engineering dogma, promoting ideas like patterns, test-driven development, and Extreme Programming. Currently affiliated with Three Rivers Institute and Agitar Software, he is the author of many Addison-Wesley titles.

Dr. Erich Gamma is technical director at the Software Technology Center of Object Technology International in Zurich, Switzerland.

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

  • A quick step-by-step tutorial. Have your first plug-in running in less than an hour.
  • An introduction to test-driven plug-in development. Confidently create higher quality plug-ins.
  • The Rules of Eclipse. Seamlessly integrate your contributions with the rest of Eclipse.
  • A design pattern tour of Eclipse. A cook's tour of Eclipse with patterns.
  • A comprehensive tutorial. See all the techniques necessary to write production-quality contributions.

Erich Gamma and Kent Beck introduce you quickly, yet thoroughly, to Eclipse, the emerging environment for software development. Instead of simply walking you through the actions you should take, Contributing to Eclipse, with its many sidebars, essays, and forward pointers, guides you through Eclipse. You will not just do. You will also understand.

Whether you need to get up to speed immediately or want to better understand the design rationale behind Eclipse, Contributing to Eclipse is the Eclipse resource for you.



0321205758B10142003

Source Code

EXAMPLES

A snapshot of all the source code developed throughout this book is available for download here.

Once you have downloaded and unpacked the zip file, please refer to the file cte-source/readme.txt for how to import the code into your Eclipse workspace for browsing.

Download the archive (ZIP, 170K)

Related Article

Eclipse Shines On, Even Without Sun

Search Term

Eric

Customer Reviews

26 of 29 people found the following review helpful
1.0 out of 5 stars What I would expect if there was NO docs for eclipse, November 5, 2004
By 
Manuel A. Ricart "aricart" (Cottage Grove, MN United States) - See all my reviews
(REAL NAME)   
This review is from: Contributing to Eclipse: Principles, Patterns, and Plug-Ins (Paperback)
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... Read more
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


12 of 12 people found the following review helpful
5.0 out of 5 stars Different is good, September 3, 2004
By 
Ernest Friedman-Hill "JavaRanch Sheriff" (Gaithersburg, MD United States) - See all my reviews
(VINE VOICE)    (REAL NAME)   
This review is from: Contributing to Eclipse: Principles, Patterns, and Plug-Ins (Paperback)
"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... Read more
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 8 people found the following review helpful
5.0 out of 5 stars Zen and the Art of Eclipse, July 30, 2004
This review is from: Contributing to Eclipse: Principles, Patterns, and Plug-Ins (Paperback)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


Share your thoughts with other customers:
 See all 15 customer reviews...

Table of Contents



Foreword.


Preface.


1. The Big Picture.

Book Goals.

Plug-In.

Eclipse in a Nutshell.

I. CIRCLE ZERO: HELLO WORLD.

2. Setting Up Eclipse for Plug-In Development.

Setting Up a Workspace.

Browsing and Searching Source.

3. Hello World.

Declaration/Implementation Split.

Hello Button.

Saying “Hello”.

II. CIRCLE ONE: BASIC PLUG-IN.

4. Der Plan.

JUnit by Example.

JUnit Integration.

5. Contributing a Menu Item to Run Tests.

6. Implementing the Menu Item Behavior.

7. Displaying the Results.

8. Defining an Extension Point.

9. Notifying Extensions.

10. Publishing.

Package the Plug-In.

Bundling the Plug-In into a Feature.

Contributing.

11. Closing Circle One.

Interlude.

12. Test-Driven Plug-In Development.

PDE JUnit.

A Test Project Fixture.

Testing the Contributed JUnit Plug-In.

And Now….

III. CIRCLE TWO: THE REST OF THE PLUG-IN.

13. Viewing Results.

Contributing a View.

Listening to Testing Progress.

Changing Colors.

14. Menu Contributions

Creating Context Menus.

Contributing Menu Items.

15. Failed Tests Are Compile Errors.

16. Test Failures as Markers.

Test for a Marker.

Passing the Project.

Creating Markers.

Deleting Markers.

Marker Images.

Marker Resolution.

17. Finding Tests.

18. Builders and Natures.

Resource Listeners Versus Builders.

Using Natures to Configure Builders.

19. Auto-Test Property.

20. Exception Handling.

IStatus, CoreException.

Presenting Exceptions in an Error Dialog.

Logging Errors.

21. Tracing—Instrumenting a Plug-In.

22. Marker Resolution--Invoking a Long-Running Operation.

Testing Marker Resolution.

Build and Rerun.

Showing Progress.

Rerunning the Test.

23. Test Report View—Using JFace.

TestResult.

The Test.

The View.

TestReportLabelProvider.

TestReportContentProvider.

Handling Events.

24. A Simple Editor to Exclude Tests.

Contributing an Editor.

Contributing a Contributor.

25. ResultView Revisited—Observing Changes.

Testing Color.

Observing Changes.

Reacting to Changes.

26. Perspectives.

Views in Perspective.

Show View Menu.

27. Help.

Top-Level Help.

Integrated Help.

Context-Sensitive Help.

28. Internationalization and Accessibility.

Externalizing Strings from the Manifest Files.

Externalizing Strings from Code.

Accessibility.

29. Publishing a Plug-In for Other Programmers.

Defining the API.

Exporting Classes.

Separating Published from Internal Packages.

Separating Core from UI.

Publishing an Extension Point—Extension Point Schemas.

30. Closing Circle Two.

Contributing.

Redeploying the Plug-In.

Where to Go Next?

IV. CIRCLE THREE: PATTERN STORIES.

31. Core Runtime—IAdaptable.

Extension Object/Extension Interface.

Surfacing Interfaces Using IAdaptable.

AdapterFactories—Adding Interfaces to Existing Types.

32. Core Workspace—Resources.

Accessing File-System Resources—Proxy and Bridge.

The Workspace—Composite.

Traversing the Resource Tree—Visitor.

Tracking Resource Changes—Observer.

Batching Changes—Execute Around Method.

33. Java Core.

From Resources to Java Elements—Adapter.

Java Elements—(Virtual) Proxy.

The Java Element Tree--Composite.

Type Hierarchies—Objectifying an Association.

Traversing the Java Model.

Tracking Java Element Changes—Observer.

Collecting Results—Builder.

Abstract Syntax Tree Analysis—Visitor.

34. Standard Widget Toolkit—SWT.

Composing Widgets—Composite.

Defining the Layout—Strategy.

Responding to Events—Observer.

35. JFace--User Interface Frameworks.

Viewers: Connecting a Widget to a Model—Pluggable Adapter.

Viewers: Customizing a Viewer without Subclassing—Strategy.

Actions—Command.

36. UI Workbench.

Implementing the Lazy Loading Rule—Virtual Proxies.

Persisting UI State—Memento.

Workbench Services—IAdaptable .

37. Closing Circle Three.

Final Forward Pointers.

An Invitation to Contribute.

V. APPENDICES.

Appendix A. TestRunner Details.

TestRunner.

SocketTestRunner.

Appendix B. The TestProject Fixture.

Appendix C. AutoTestBuilder with Exclusion Support.

References.

Index. 0321205758T10202003

Downloadable Sample Chapter

Download the Sample Chapter related to this title.

Foreword

Eclipse is a many-splendored thing. Eclipse is a technology, an extensible platform for tool integration, and a wide range of tools built on that platform. Eclipse is an open source project that delivers this technology. And Eclipse is a community that contributes to the open source project and also produces commercial Eclipse-based tools. The community itself is diverse, ranging from users of Eclipse-based products, to tool writers building extensions, to researchers exploring new ways of using Eclipse.

Eclipse is an ambitious undertaking. It provides a platform that allows diverse tools to interoperate, often in ways that the tool writers did not initially imagine. To make this aim a reality, we use an open, merit-based, collaborative development process--high-quality contributions are accepted from anyone. As the Contribution Rule reminds us, "Everything is a contribution." And with many contributions, the possibilities are endless.

The Eclipse Platform is composed of numerous plug-ins, and if you cast your net more widely, you will discover a plethora of additional plug-ins. Contributing to Eclipse enables you to jump into this expanding ecosystem and become a tool writer yourself. It is a guide through the initial barrier to entry, giving you the tools to explore the Eclipse landscape and venture out on your own. A fully worked example takes you step by step through the evolution of a plug-in--from initial implementation to product-ready software. In addition, this book defines Rules for extending Eclipse, so your plug-ins are "done right." Eclipse-literate readers will appreciate this book too: Its instruction confirms your accumulated understanding and it provides new insights into areas where you are less experienced. Chapters end with forwarding pointers to additional material so you can dive deeper.

These authors know what they are talking about. Erich is the authoritative source on the Java development tooling. In addition to leading this effort, he has been influential in the evolution and maturation of the Eclipse Platform. Kent has a deep understanding of software development processes and he is a master at providing clarity, simplicity, and understanding. Together, they share their experiences with Eclipse and teach us how our own experiences can be successful. I trust you will enjoy this refreshingly practical book while you absorb its instruction on how to immerse yourself into Eclipse.

On a personal note, Erich and I have been collaborating on IDE technology for several years. The previous efforts were educational stepping stones--sometimes not even completed before we moved on to the next iteration. But we kept learning. With Eclipse, we have a technology that will continue to grow and evolve. Eclipse is worth investing in. Put Eclipse to work for you. I have confidence you will find new ways to contribute to Eclipse!

John Wiegand
Eclipse Platform Lead
IBM
September 2003

Index

Download the Index file related to this title.

 
Buy

Book  $44.99  $35.99

Usually ships in 24 hours.

This book includes free shipping!

Purchase Reward: One Month Free Subscription
By completing any purchase on InformIT, you become eligible for an unlimited access one-month subscription to Safari Books Online.

Get access to thousands of books and training videos about technology, professional development and digital media from more than 40 leading publishers, including Addison-Wesley, Prentice Hall, Cisco Press, IBM Press, O'Reilly Media, Wrox, Apress, and many more. If you continue your subscription after your 30-day trial, you can receive 30% off a monthly subscription to the Safari Library for up to 12 months. That's a total savings of $199.