Contributing to Eclipse: Principles, Patterns, and Plug-Ins (The Eclipse Series) / Edition 1

Paperback (Print)
Buy New
Buy New from BN.com
$36.83
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 95%)
Other sellers (Paperback)
  • All (18) from $1.99   
  • New (5) from $35.19   
  • Used (13) from $1.99   

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

Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
Developers have grown accustomed to tools that force you to work more or less the way they want you to. But it hasn’t always been that way. Some may remember the heyday of Smalltalk, which treated every user as a potential programmer. (Don’t like the way your editor works? Change it.) Now, there’s an open source software project that brings that philosophy back to life: Eclipse.

From the outset, Eclipse has envisioned an endless “Contribution Circle” that benefits everyone involved. Users become configurers, thoroughly adjusting Eclipse to their unique needs. Configurers become extenders, plugging in new functionality they’ve created. Extenders become publishers, sharing their functionality with the world. Publishers become enablers, providing hooks others can use to further extend the contributions they’ve published. Finally, having earned the trust of the community, enablers become committers, able to contribute changes to the source code in the global Eclipse release. Contributing to Eclipse is about becoming part of that contribution circle -- and reaping its benefits.

Authored by the legendary Erich Gamma (Design Patterns' “Gang of Four”) and Kent Beck (of Extreme Programming fame), this book has three goals. First, using plenty of examples, it thoroughly explains the basic concepts and details you need in order to contribute to Eclipse at any level. Second, it teaches you how to learn even more about Eclipse, whenever you need to know it. Third, maybe most important -- and not surprising, given who wrote it -- the book is a primer on Eclipse’s sophisticated design principles. Of course, those principles aren’t just relevant to Eclipse, but to any system you might be involved with.

The authors begin by walking you through the Eclipse architecture at a high level, then setting you up for plug-in development, and walking you through just about the simplest possible example (You’ll add a button to the toolbar. When you click the button, a dialog box will appear, announcing -- yup, the old standby -- Hello World.)

Next, you’ll drill down with a more detailed example: the authors’ own JUnit regression testing framework for implementing unit tests in Java. They start simple, using JUnit as existing functionality that will be accessed through Eclipse, and using the extension of JUnit for testing plug-ins, PDE JUnit. Next, they add the elements required for a complete Eclipse contribution. As the authors put it, collectively, “The contributions add up to a new way to think about tests during the development process, and each bit shows you a useful corner of Eclipse.”

Along the way, you’ll walk through implementing menu items, displaying results, defining extension points that allow others to extend JUnit, and packaging your plug-in. Gamma and Beck cover a wide range of issues associated with Eclipse development and testing, ranging from auto-test properties and exception handling to tracing, markers and marker resolution, and test reporting using JFace.

Last but not least, the authors present a “designer-to-designer” tour of Eclipse built around design and implementation patterns, and showing how these patterns play out in diverse contexts. If you care about design at all, you’ll find this stuff invaluable. Bill Camarda

Bill Camarda is a consultant, writer, and web/multimedia content developer. His 15 books include Special Edition Using Word 2000 and Upgrading & Fixing Networks for Dummies, Second Edition.

Read More Show Less

Product Details

  • ISBN-13: 9780321205759
  • Publisher: Addison-Wesley
  • Publication date: 10/31/2003
  • Series: The Eclipse Series
  • Edition description: First Edition
  • Edition number: 1
  • Pages: 395
  • Product dimensions: 6.90 (w) x 9.00 (h) x 1.00 (d)

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

Read More Show Less

Read an Excerpt

Humans need to feel nurtured and cared for. Humans also need to nurture and care for others. Fulfilling the need to nurture and be nurtured is what makes becoming a fully functioning Eclipse programmer so satisfying. This experience is wrapped in all sorts of rational explanations—"productivity," "time-to-market," "leverage." Eclipse is a productive environment in which to work, and contributing to it makes it more so. The right contributions written by the right person can create a highly leveraged reduction in time-to-market. While these explanations are true, though, they aren't the point.

Working in Eclipse feels good to us because our needs are being taken care of by our environment. When we have a programming problem, there is an Eclipse feature that helps us with it. Contributing to Eclipse feels good to us because we know we are adding to that nurturing feeling of nurturing for ourselves and other programmers. When our contributions enable others to make further contributions of their own, a positive feedback loop appears. That positive feedback feels satisfying.

Contributing to Eclipse also has the potential to become an exciting business proposition. You can use Eclipse to ship fully featured products, or you can ship contributions that extend existing products.

Eclipse is powerful—personally, professionally, and socially. But there is a daunting amount of information necessary to join the cycle of contribution. We hope reading this book will help you get over this initial hurdle and begin contributing.

Eclipse is good news and bad news for developers who like writing tools for developers. The good news is that the platform is incredibly powerful and the internal developers have followed all the rules in creating the Eclipse Java development tools. The bad news is that Eclipse has a strong world view. If you want to play nicely in Eclipse's sandbox, you need to learn the rules.

Beginning with Eclipse feels a bit like parachuting blindfolded into Bangkok (this analogy doesn't apply to Thai programmers). When you land you know you need food and shelter, but how are you going to get it? How can you map your clear desires onto the resources available?

Overcoming this feeling of dislocation is the primary goal of Contributing to Eclipse. If you parachuted into Bangkok with a guide, you could say, "I'm hungry," and your guide would say, "Here's the kind of place you can get a meal." Similarly, we can listen to, "I want to build such and so," and tell you, "This should be its own perspective, that is an object contribution, and you'll need a new editor for that."

When you are finished with this book, you won't have a complete map of Eclipse, but you'll know at least one place to get each of your basic needs met. You will also know the rules through which you can play well with others. It's as if we draw you a map of Bangkok marked with six streets, a restaurant, and a hotel. You won't know everything, but you'll know enough to survive, and enough to learn more.

When you learn Eclipse, you'll spend much more time reading code than writing code. You will have to grow accustomed to incredibly productive days in which you spend six hours reading and one hour typing. After you become familiar with Eclipse culture, you'll "just know" how to solve more and more problems. However, you'll always solve problems by copying the structure of solutions to similar problems, whether by mimicking Eclipse structure or the structure of your own previous efforts.

As we walk together through our example, we won't pretend that we perfectly remember all the details. Instead, we'll show you how we found structure to mimic. Learning to effectively use Eclipse's search facilities is part of becoming an Eclipse contributor.

This book is not intended for beginners just learning to use Eclipse. We assume a familiarity with the vocabulary of Eclipse—views, editors, and so on. Once you've used Eclipse for a while, you are likely to come up with ideas for extending it. That's when this book comes into play.

When we laid out Contributing to Eclipse, we had a daunting stack of concepts to cover. If we tried to tell you about all 2,000 ideas in Eclipse, though, we would have a book that would cut off the circulation to your lower extremities. In deference to your feet, we've chosen the 50 things that we think are most important for getting you started. Many chapters conclude with "Forward Pointers," places in the code where you can explore the extension of the concepts covered in the chapter. When we teach Eclipse, this is exactly the structure we use—"Why don't you look at the

org.eclipse.core.runtime manifest?"

Once there was a doctoral student who had to take a qualifying exam about fruit. He only had enough time, though, to learn about cucumbers. When the time came for the exam, the first question was, "Tell us about the tomato." "You see," he said, "the tomato, like the cucumber, is actually a fruit. The cucumber is 80 percent water, has a disease-resistant skin, and is used in salads." Every question that came up, he answered with cucumber facts.

We know cucumbers. Except in our case, there are two cucumbers: patterns and JUnit. You'll find pattern-y advice throughout the book. In fact, we were uncomfortable with writing until we started writing the Rules. Once we had the concept of Rules, we could proceed happily. The Rules are really patterns in a micro format.

JUnit, our second cucumber, is the basis for the running example. We wrote JUnit in a few hours in a plane over the Atlantic in 1997. Since then, it seems much of our technical lives have revolved around it. JUnit is fertile ground for an Eclipse example because the core—running tests—is simple but the implications—the presentation of tests and results—have barely been explored.We did want to warn you, though, that if you're tired of hearing about patterns and JUnit, this is probably not the book for you.

Conventions Used in This Book

The following formatting conventions are used throughout the book:

  • Bold—Used for the names of user-interface elements, including menus, buttons, tabs, and text boxes.
  • Italic—Used for filenames and URLs. Also, new terms are italicized for emphasis.
  • Courier—Used for all code samples and for in-text references to code elements. Plug-in names and elements of

  • Courier Bold—Used to emphasize portions of code samples, in particular insertions or changes.

  • Courier Strikethrough—Used in code samples to indicate where text should be deleted.

In the example presented in Parts II and III, we use specific icons to indicate our current activity:

  • Searching—Shown when we search and explore the Eclipse code.
  • Mimicking—Shown when we present code and
  • Testing—Shown when we present code from a JUnit test.
Online Examples

The Web site for this book is located at www.awprofessional.com/titles/0321205758. A snapshot of all the source code developed throughout this book can be downloaded from there. The site will also provide an errata list and other news related to the book.To use the examples, the Eclipse SDK (Version 2.1.1) is required. You can find a build of the Eclipse SDK for your platform by visiting www.eclipse.org/downloads/.

Read More Show Less

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

Read More Show Less

Preface

Humans need to feel nurtured and cared for. Humans also need to nurture and care for others. Fulfilling the need to nurture and be nurtured is what makes becoming a fully functioning Eclipse programmer so satisfying. This experience is wrapped in all sorts of rational explanations--"productivity," "time-to-market," "leverage." Eclipse is a productive environment in which to work, and contributing to it makes it more so. The right contributions written by the right person can create a highly leveraged reduction in time-to-market. While these explanations are true, though, they aren't the point.

Working in Eclipse feels good to us because our needs are being taken care of by our environment. When we have a programming problem, there is an Eclipse feature that helps us with it. Contributing to Eclipse feels good to us because we know we are adding to that nurturing feeling of nurturing for ourselves and other programmers. When our contributions enable others to make further contributions of their own, a positive feedback loop appears. That positive feedback feels satisfying.

Contributing to Eclipse also has the potential to become an exciting business proposition. You can use Eclipse to ship fully featured products, or you can ship contributions that extend existing products.

Eclipse is powerful--personally, professionally, and socially. But there is a daunting amount of information necessary to join the cycle of contribution. We hope reading this book will help you get over this initial hurdle and begin contributing.

Eclipse is good news and bad news for developers who like writing tools for developers. The good news is that the platform is incredibly powerful and the internal developers have followed all the rules in creating the Eclipse Java development tools. The bad news is that Eclipse has a strong world view. If you want to play nicely in Eclipse's sandbox, you need to learn the rules.

Beginning with Eclipse feels a bit like parachuting blindfolded into Bangkok (this analogy doesn't apply to Thai programmers). When you land you know you need food and shelter, but how are you going to get it? How can you map your clear desires onto the resources available?

Overcoming this feeling of dislocation is the primary goal of Contributing to Eclipse. If you parachuted into Bangkok with a guide, you could say, "I'm hungry," and your guide would say, "Here's the kind of place you can get a meal." Similarly, we can listen to, "I want to build such and so," and tell you, "This should be its own perspective, that is an object contribution, and you'll need a new editor for that."

When you are finished with this book, you won't have a complete map of Eclipse, but you'll know at least one place to get each of your basic needs met. You will also know the rules through which you can play well with others. It's as if we draw you a map of Bangkok marked with six streets, a restaurant, and a hotel. You won't know everything, but you'll know enough to survive, and enough to learn more.

When you learn Eclipse, you'll spend much more time reading code than writing code. You will have to grow accustomed to incredibly productive days in which you spend six hours reading and one hour typing. After you become familiar with Eclipse culture, you'll "just know" how to solve more and more problems. However, you'll always solve problems by copying the structure of solutions to similar problems, whether by mimicking Eclipse structure or the structure of your own previous efforts.

As we walk together through our example, we won't pretend that we perfectly remember all the details. Instead, we'll show you how we found structure to mimic. Learning to effectively use Eclipse's search facilities is part of becoming an Eclipse contributor.

This book is not intended for beginners just learning to use Eclipse. We assume a familiarity with the vocabulary of Eclipse--views, editors, and so on. Once you've used Eclipse for a while, you are likely to come up with ideas for extending it. That's when this book comes into play.

When we laid out Contributing to Eclipse, we had a daunting stack of concepts to cover. If we tried to tell you about all 2,000 ideas in Eclipse, though, we would have a book that would cut off the circulation to your lower extremities. In deference to your feet, we've chosen the 50 things that we think are most important for getting you started. Many chapters conclude with "Forward Pointers," places in the code where you can explore the extension of the concepts covered in the chapter. When we teach Eclipse, this is exactly the structure we use--"Why don't you look at the org.eclipse.core.runtime manifest?"

Once there was a doctoral student who had to take a qualifying exam about fruit. He only had enough time, though, to learn about cucumbers. When the time came for the exam, the first question was, "Tell us about the tomato." "You see," he said, "the tomato, like the cucumber, is actually a fruit. The cucumber is 80 percent water, has a disease-resistant skin, and is used in salads." Every question that came up, he answered with cucumber facts.

We know cucumbers. Except in our case, there are two cucumbers: patterns and JUnit. You'll find pattern-y advice throughout the book. In fact, we were uncomfortable with writing until we started writing the Rules. Once we had the concept of Rules, we could proceed happily. The Rules are really patterns in a micro format.

JUnit, our second cucumber, is the basis for the running example. We wrote JUnit in a few hours in a plane over the Atlantic in 1997. Since then, it seems much of our technical lives have revolved around it. JUnit is fertile ground for an Eclipse example because the core--running tests--is simple but the implications--the presentation of tests and results--have barely been explored.We did want to warn you, though, that if you're tired of hearing about patterns and JUnit, this is probably not the book for you.

Conventions Used in This Book

The following formatting conventions are used throughout the book:

  • Bold--Used for the names of user-interface elements, including menus, buttons, tabs, and text boxes.
  • Italic--Used for filenames and URLs. Also, new terms are italicized for emphasis.
  • Courier--Used for all code samples and for in-text references to code elements. Plug-in names and elements of XML files also appear in this font.
  • Courier Bold --Used to emphasize portions of code samples, in particular insertions or changes.
  • Courier Strikethrough --Used in code samples to indicate where text should be deleted.

In the example presented in Parts II and III, we use specific icons to indicate our current activity:

  • Searching--Shown when we search and explore the Eclipse code.
  • Mimicking--Shown when we present code and XML markup from Eclipse.
  • Testing--Shown when we present code from a JUnit test.

Online Examples

The Web site for this book is located at www.awprofessional.com/titles/0321205758. A snapshot of all the source code developed throughout this book can be downloaded from there. The site will also provide an errata list and other news related to the book.To use the examples, the Eclipse SDK (Version 2.1.1) is required. You can find a build of the Eclipse SDK for your platform by visiting www.eclipse.org/downloads/.

0321205758P10242003

Read More Show Less

Introduction

Humans need to feel nurtured and cared for. Humans also need to nurture and care for others. Fulfilling the need to nurture and be nurtured is what makes becoming a fully functioning Eclipse programmer so satisfying. This experience is wrapped in all sorts of rational explanations--"productivity," "time-to-market," "leverage." Eclipse is a productive environment in which to work, and contributing to it makes it more so. The right contributions written by the right person can create a highly leveraged reduction in time-to-market. While these explanations are true, though, they aren't the point.

Working in Eclipse feels good to us because our needs are being taken care of by our environment. When we have a programming problem, there is an Eclipse feature that helps us with it. Contributing to Eclipse feels good to us because we know we are adding to that nurturing feeling of nurturing for ourselves and other programmers. When our contributions enable others to make further contributions of their own, a positive feedback loop appears. That positive feedback feels satisfying.

Contributing to Eclipse also has the potential to become an exciting business proposition. You can use Eclipse to ship fully featured products, or you can ship contributions that extend existing products.

Eclipse is powerful--personally, professionally, and socially. But there is a daunting amount of information necessary to join the cycle of contribution. We hope reading this book will help you get over this initial hurdle and begin contributing.

Eclipse is good news and bad news for developers who like writing tools for developers. Thegood news is that the platform is incredibly powerful and the internal developers have followed all the rules in creating the Eclipse Java development tools. The bad news is that Eclipse has a strong world view. If you want to play nicely in Eclipse's sandbox, you need to learn the rules.

Beginning with Eclipse feels a bit like parachuting blindfolded into Bangkok (this analogy doesn't apply to Thai programmers). When you land you know you need food and shelter, but how are you going to get it? How can you map your clear desires onto the resources available?

Overcoming this feeling of dislocation is the primary goal of Contributing to Eclipse. If you parachuted into Bangkok with a guide, you could say, "I'm hungry," and your guide would say, "Here's the kind of place you can get a meal." Similarly, we can listen to, "I want to build such and so," and tell you, "This should be its own perspective, that is an object contribution, and you'll need a new editor for that."

When you are finished with this book, you won't have a complete map of Eclipse, but you'll know at least one place to get each of your basic needs met. You will also know the rules through which you can play well with others. It's as if we draw you a map of Bangkok marked with six streets, a restaurant, and a hotel. You won't know everything, but you'll know enough to survive, and enough to learn more.

When you learn Eclipse, you'll spend much more time reading code than writing code. You will have to grow accustomed to incredibly productive days in which you spend six hours reading and one hour typing. After you become familiar with Eclipse culture, you'll "just know" how to solve more and more problems. However, you'll always solve problems by copying the structure of solutions to similar problems, whether by mimicking Eclipse structure or the structure of your own previous efforts.

As we walk together through our example, we won't pretend that we perfectly remember all the details. Instead, we'll show you how we found structure to mimic. Learning to effectively use Eclipse's search facilities is part of becoming an Eclipse contributor.

This book is not intended for beginners just learning to use Eclipse. We assume a familiarity with the vocabulary of Eclipse--views, editors, and so on. Once you've used Eclipse for a while, you are likely to come up with ideas for extending it. That's when this book comes into play.

When we laid out Contributing to Eclipse, we had a daunting stack of concepts to cover. If we tried to tell you about all 2,000 ideas in Eclipse, though, we would have a book that would cut off the circulation to your lower extremities. In deference to your feet, we've chosen the 50 things that we think are most important for getting you started. Many chapters conclude with "Forward Pointers," places in the code where you can explore the extension of the concepts covered in the chapter. When we teach Eclipse, this is exactly the structure we use--"Why don't you look at the org.eclipse.core.runtime manifest?"

Once there was a doctoral student who had to take a qualifying exam about fruit. He only had enough time, though, to learn about cucumbers. When the time came for the exam, the first question was, "Tell us about the tomato." "You see," he said, "the tomato, like the cucumber, is actually a fruit. The cucumber is 80 percent water, has a disease-resistant skin, and is used in salads." Every question that came up, he answered with cucumber facts.

We know cucumbers. Except in our case, there are two cucumbers: patterns and JUnit. You'll find pattern-y advice throughout the book. In fact, we were uncomfortable with writing until we started writing the Rules. Once we had the concept of Rules, we could proceed happily. The Rules are really patterns in a micro format.

JUnit, our second cucumber, is the basis for the running example. We wrote JUnit in a few hours in a plane over the Atlantic in 1997. Since then, it seems much of our technical lives have revolved around it. JUnit is fertile ground for an Eclipse example because the core--running tests--is simple but the implications--the presentation of tests and results--have barely been explored. We did want to warn you, though, that if you're tired of hearing about patterns and JUnit, this is probably not the book for you.

Conventions Used in This Book

The following formatting conventions are used throughout the book:

  • Bold--Used for the names of user-interface elements, including menus, buttons, tabs, and text boxes.
  • Italic--Used for filenames and URLs. Also, new terms are italicized for emphasis.
  • Courier--Used for all code samples and for in-text references to code elements. Plug-in names and elements of XML files also appear in this font.
  • Courier Bold--Used to emphasize portions of code samples particular insertions or changes.
  • Courier Strikethrough--Used in code samples to indicate where text should be deleted.

In the example presented in Parts II and III, we use specific icons to indicate our current activity:

  • Searching--Shown when we search and explore the Eclipse code.
  • Mimicking--Shown when we present code and XML markup from Eclipse.
  • Testing--Shown when we present code from a JUnit test.

Online Examples

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 3 Customer Reviews
  • Anonymous

    Posted July 30, 2004

    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.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted December 2, 2003

    Best Book Ever!

    This book is phenomenal. Why? Eclipse is one big example of how to do engineer software. You look at different Aspects of Eclipse and go, 'How did they design and implement that?'. The authors are diligent in not just answering specific questions, but showing you how you can answer other questions as well. This is what is so phenomenal about this book. A perfect example of 'Teach a man how to fish...'.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted December 2, 2003

    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.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 3 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)