- STAFF PICKS
- GIFTS + GIFT CARDS
- SELL BOOKS
- FIND A STORE
New Trade Paper
Ships in 1 to 3 days
available for shipping or prepaid pickup only
Available for In-store Pickup
in 7 to 12 days
More copies of this ISBN
Contributing to Eclipse: Principles, Patterns, and Plug-Ins (Eclipse Series)by Erich Gamma
Synopses & Reviews
"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
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.
Book News Annotation:
This book explains how to extend Eclipse for software projects and how to use Eclipse to create software tools that improve development time. It serves as a tutorial on creating custom tools and promotes an overall software design philosophy based the building and applying of new tools to support of existing work. The authors are programmers and software developers.
Annotation ©2004 Book News, Inc., Portland, OR (booknews.com)
Written by two world class programmers and software designers, this guide explains how to extend Eclipse for software projects and how to use Eclipse to create software tools that improve development time.
This book explains how to extend Eclipse for software projects and how to use Eclipse to create software tools that improve development time. It serves as a tutorial on creating custom tools and promotes an overall software design philosophy based the building and applying of new tools to support of
About the Author
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.
Table of Contents
1. The Big Picture.
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.
II. CIRCLE ONE: BASIC PLUG-IN.
4. Der Plan.
JUnit by Example.
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.
Package the Plug-In.
Bundling the Plug-In into a Feature.
11. Closing Circle One.
12. Test-Driven Plug-In Development.
A Test Project Fixture.
Testing the Contributed JUnit Plug-In.
III. CIRCLE TWO: THE REST OF THE PLUG-IN.
13. Viewing Results.
Contributing a View.
Listening to Testing Progress.
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.
17. Finding Tests.
18. Builders and Natures.
Resource Listeners Versus Builders.
Using Natures to Configure Builders.
19. Auto-Test Property.
20. Exception Handling.
Presenting Exceptions in an Error Dialog.
21. Tracing—Instrumenting a Plug-In.
22. Marker Resolution--Invoking a Long-Running Operation.
Testing Marker Resolution.
Build and Rerun.
Rerunning the Test.
23. Test Report View—Using JFace.
24. A Simple Editor to Exclude Tests.
Contributing an Editor.
Contributing a Contributor.
25. ResultView Revisited—Observing Changes.
Reacting to Changes.
Views in Perspective.
Show View Menu.
28. Internationalization and Accessibility.
Externalizing Strings from the Manifest Files.
Externalizing Strings from Code.
29. Publishing a Plug-In for Other Programmers.
Defining the API.
Separating Published from Internal Packages.
Separating Core from UI.
Publishing an Extension Point—Extension Point Schemas.
30. Closing Circle Two.
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.
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.
Abstract Syntax Tree Analysis—Visitor.
34. Standard Widget Toolkit—SWT.
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.
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.
Appendix A. TestRunner Details.
Appendix B. The TestProject Fixture.
Appendix C. AutoTestBuilder with Exclusion Support.
What Our Readers Are Saying
Other books you might like