The Java Developer's Guide to Eclipse, 2nd Edition
Read an excerpt:
Chapter 3: Using Java Development Tools
Excerpt provided courtesy of Addison-Wesley Professional. Copyright © Addison-Wesley. Written permission from the publisher is required for any use of this material.
|
Be the First to Write a Review and tell the world about this title!People who purchase this book frequently purchase: - Java in a Nutshell, 5th Edition; David Flanagan, $26.95, 40% Off!
- Professional Eclipse 3 for Java Developers; Berthold Daum, $30.50, 39% Off!
- Eclipse Cookbook; Steve Holzter, $26.95, 40% Off!
- Head First Design Patterns; Eric Freeman, et al, $26.95, 40% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
“Fully updated and revised for Eclipse 3.0, this book is the definitive
Eclipse reference—an indispensable guide for tool builders, rich client application
developers, and anyone customizing or extending the Eclipse environment.”
—Dave Thomson, Eclipse Project Program Director, IBM
The Ultimate Guide to Eclipse 3.0 for the Java Developer. No Eclipse Experience
Required!
Eclipse is a world-class Java integrated development environment (IDE) and
an open source project and community. Written by members of the IBM Eclipse
Jumpstart team, The Java™ Developer’s Guide to Eclipse, Second Edition,
is the definitive Eclipse companion. As in the best-selling first edition, the
authors draw on their considerable experience teaching Eclipse and mentoring
developers to provide guidance on how to customize Eclipse for increased productivity
and efficiency.
In this greatly expanded edition, readers will find
- A total update, including the first edition’s hallmark, proven exercises—all
revised to reflect Eclipse 3.0 changes to the APIs, plug-ins, UI, widgets,
and more
- A special focus on rich client support with a new chapter and two exercises
- A comprehensive exercise on using Eclipse to develop a Web commerce application
using Apache’s Tomcat
- A new chapter on JFace viewers and added coverage of views
- A new chapter on internationalization and accessibility
- New chapters on performance tuning and Swing interoperability
Using this book, those new to Eclipse will become proficient with it, while
advanced developers will learn how to extend Eclipse and build their own Eclipse-based
tools. The accompanying CD-ROM contains Eclipse 3.0, as well as exercise solutions
and many code examples.
Whether you want to use Eclipse and Eclipse-based offerings as your integrated
development environment or customize Eclipse further, this must-have book will
quickly bring you up to speed.
Preface
Origin of the Book
Starting in late 1999, the authors formed the core of a group within IBM called
the Eclipse Jumpstart team. The team was created to share knowledge of what
would become Eclipse technology throughout IBM and with its business partners—that
is, to “jumpstart” the IBM and IBM partner development community on
Eclipse. Part of this effort included the creation of a set of presentations,
lecture materials, and accompanying exercises. Over the ensuing months, as the
Eclipse technology matured, the presentations and exercises matured as well.
As the Eclipse community grew to include various companies and academic institutions,
requests for this information also grew. After every class we taught, we revised
and improved the materials. When our schedules could not keep pace with the
demand, we adapted the materials and made them available for use in a self-study
mode. This was the genesis of this book. You can think of each chapter in the
book as a classroom lesson. The exercises and examples reinforce the concepts
of the chapters and provide you with practice using or extending aspects of
Eclipse.
The Second Edition
Late 2003 found most of the original authors still actively engaged in Eclipse.
We have been unexpectedly and very pleasantly surprised with the public acceptance
of the first edition. The public and private commentary on the first edition
was very positive. In July 2004 the first edition received an Editors’
Choice Award from the Java Developers Journal. The authors express their sincerest
thanks and appreciation to our many readers. With the first edition barely six
months old, we realized that Eclipse 3.0 would be very special and has the potential
to take Eclipse to new heights. It will reach a much larger developer community
and potentially millions of users now that Eclipse is not limited to integrated
development environments (IDEs) but can host any kind of client application.
The authors remain passionate about this technology and the opportunities it
offers for innovative tools and applications. We decided to create a second
edition earlier than planned. Our objectives for the second edition were to
upgrade the book to Eclipse 3.0, improve it based on reader feedback, and add
a select number of new topics. This edition is nearing the limit in sheer weight
and volume that anyone should have to carry. We hope it continues to serve you
and the Eclipse community well.
What’s New in the Second Edition
- All chapters, exercises, and examples from the first edition are updated
for Eclipse 3.0.
- The Guide to Reading This Book section has been added. This topic provides
a plan to help readers who are new to Eclipse get the most from this comprehensive
book.
- There are seven new chapters and three new exercises. There is a special
focus on the new rich client support. The book was restructured to acknowledge
this significant new feature. A chapter is devoted to the rich client topic
along with two detailed exercises. One of the exercises demonstrates the new
Eclipse runtime support for dynamic plug-ins.
- For readers who use Eclipse as their Java development environment, a new
exercise is included in which you develop a simple Web commerce site using
a Java servlet application running on an Apache Tomcat server.
- There is an entirely new introduction to extending Eclipse. A comprehensive
chapter devoted to JFace viewers was added and the chapter on views has been
expanded. The chapter on concurrency will show you how to create a more responsive
user interface by delegating work for processing behind the scenes. You can
better manage a rich or complex user interface after reading the chapter on
Eclipse capabilities. A chapter devoted to plug-in performance tuning will
help you avoid common development pitfalls. A new chapter on internationalization
and accessibility will help you develop products that reach wider markets.
The chapter on Java Swing interoperability covers Eclipse’s improved
support for Swing.
- The book’s organization has been restructured, reflecting both the
size of the book and the breadth of Eclipse functionality. The book is divided
into six parts. Part I is devoted to Eclipse users, and Parts II through V
are for developers extending Eclipse. Part VI includes detailed exercises
for both using and extending Eclipse.
- The CD-ROM has been restructured for easier access and loading. There are
many new examples. All of the example documentation has been packaged into
its own help book that can be installed alongside the other books in the Eclipse
online help.
Final screenshots in this book were created just as Eclipse 3.0 was about to
ship. There may be minor discrepancies between the images in this book and the
final version of Eclipse.
Goals
We have several goals in bringing this book to you.
- Provide information for those new to Eclipse—A new user can leverage
this book as a tutorial and a later as a reference. We do not assume prior
Eclipse knowledge.
- Explore the capabilities of Eclipse—The book covers both using Eclipse
as your development environment and extending Eclipse. The chapters in Part
I start with Eclipse as a general development environment and then progress
to developing and debugging Java, as well as more advanced usage topics, for
example, using Eclipse in a team environment. The chapters on extending Eclipse
in Parts II through V cover the most frequently used classes in the Eclipse
framework. References to design patterns, where applicable, illustrate the
architectural relationships among the classes. The intent is not to replace
the Javadoc that is included with Eclipse but to complement the documentation
by focusing on how to bring a set of classes together to complete a task.
- Provide exercises and working examples that are simple and focused on the
chapter topic—The exercises and examples augment the chapter topics and
illustrate key points. The chapter text concentrates on the concepts and outlines
the basic steps to accomplish a task while providing small sections of code
or screen captures to illustrate the point. The exercises provide detailed
coding instructions and screen captures to apply the concepts described in
the chapter. The CD-ROM that comes with this book contains solutions to the
step-by-step exercises as well as additional working examples to supplement
chapters in the book.
- Provide comprehensive coverage of Eclipse that is usable at any level of
experience—The fundamentals of Eclipse are covered, providing a foundation.
From there you are free to roam among the many additional topics based on
your needs and interests.
- Promote the Eclipse community—This book provides you with the basic
knowledge of Eclipse so that you can become an active participant and help
grow the Eclipse open source community.
Although the term “Eclipse” conveys the image of a solar event causing
darkness, the intent of this book is to shed light, add clarity, and focus on
a powerful new platform. Whether you are new to Eclipse or one of the early
adopters, we welcome you to the Eclipse community.
Intended Audience and Prerequisites
The audience for this book includes Java programmers who plan to use Eclipse
as their development environment, those who will use Eclipse-based offerings,
advanced users who want to customize Eclipse further, tool providers who seek
to develop tools that will integrate with Eclipse, and application developers
who want to use Eclipse as the framework for their client applications. Prior
experience with Eclipse is not necessary; however, this book assumes that you
are familiar with the Java programming language. While it describes how to use
the Java Development Tools provided by Eclipse, it does not teach the syntax
and semantics of the Java programming language.
How the Book Is Organized
This comprehensive book can help you learn to use and extend Eclipse. After
you have mastered the basics, you will likely use this book as a reference.
To help you learn Eclipse, you should start with the Guide to Reading This Book
section. It breaks down this formidable text into manageable chunks that you
can read in a sequence better suited for learning.
The book is divided into six parts.
Part I, Using Eclipse, applies to those using Eclipse as their development
environment. The book begins by covering the basic navigation and terminology
of Eclipse. You will learn about the Java development environment, including
secrets to becoming a power user. Using Eclipse in a team programming environment
is explained. You will learn how to use the flexibility of Eclipse to maximize
your productivity and fit your own personal style. Students who are studying
the Java programming language may find using Eclipse, instead of simply a command
line environment, a much more productive and exciting way to learn the richness
and power of the language. Instructors may discover how using Eclipse in the
classroom will accelerate the student’s mastery of the language and be
a productive tool to use in research.
Part II, Fundamentals of Extending Eclipse, focuses on the important
elements of extending Eclipse independent of whether you are extending Eclipse
to develop tools or creating a client application. It covers the architecture
of Eclipse, how to develop plug-ins, the creation of client applications using
the rich client support, how to make your plug-ins extensible to others, and
packaging and deployment.
Part III, Extending the Eclipse Workbench, covers the most commonly
required topics to extend Eclipse functionality. Using the Eclipse architecture
as a base, Part III covers the frameworks needed to extend the Eclipse user
interface. It covers basic graphical user interface (GUI) development using
the Standard Widget Toolkit (SWT), dialogs and wizards, menus, viewers, views,
editors, perspectives, and online documentation.
Part IV, Extending the Eclipse IDE, focuses on those services that apply
when extending Eclipse as an IDE. This is in contrast to Part II, which covers
services that apply to both IDE-based and non-IDE-based applications. Part IV
includes topics like accessing the workspace and extending the Java Development
Tools.
Part V, Extensibility Special Topics, rounds out your knowledge of Eclipse
by covering a variety of topics that you may not need right away or that are
specialized to specific situations. Chapters covering serviceability, Swing
interoperability, concurrency, capabilities, performance tuning, OLE and ActiveX
support (Windows), and internationalization are among the topics in Part V.
Learning in a programming environment without actually writing code is difficult.
Part VI, Exercises, contains a series of detailed exercises to reinforce the
concepts presented in the book. Part VI depends on the files included on the
CD-ROM. The CD-ROM contains solutions to all of the exercises and contains many
code samples augmenting the material in the chapters. The exercises do not depend
on one another, so you can perform them in any order.
Many chapters contain a reference to the book Official Eclipse 3.0 FAQs by
John Arthorne and Chris Laffra (Boston, MA: Addison-Wesley, 2004). We recommend
it as a complementary addition to this book. Specific frequently asked questions
(FAQs) that augment the chapter content are cited in the chapter references
and on the CD-ROM.
Table of Contents
Foreword.
Preface.
Origin of the Book.
Goals.
Intended Audience and Prerequisites.
How the Book Is Organized.
Coding Conventions.
CD-ROM.
Where to Find Further Information.
Guide to Reading This Book.
Acknowledgments.
About the Authors.
1. Read Me First.
Eclipse as a Host for Application Development Tools.
Beyond Tools: Eclipse as a Host for Client Applications.
What Is Eclipse?
Getting and Installing Eclipse.
Chapter Summary.
References.
I. USING ECLIPSE.
2. Getting Started with Eclipse.
Your First Steps.
Basic Eclipse Use.
Resource Management.
Customizing Eclipse.
Exercise Summary.
Chapter Summary.
Reference.
3. Using Java Development Tools.
Getting Started with JDT.
Writing Java Code.
Working with Java Elements.
Tuning the Performance of the JDT.
More on the JDT Views and Preferences.
Exercise Summary.
Chapter Summary.
Reference.
4. Running and Debugging Java.
Running Java Code.
Debugging.
Remote Debugging.
Exercise Summary.
Chapter Summary.
Reference.
5. Teaming Up with Eclipse.
Eclipse Support for CVS.
General Team Support by Eclipse.
An Overview of CVS for the Novice.
The CVS User Interface in Eclipse.
Special Situations and How to Handle Them.
Additional Features.
Exercise Summary.
Chapter Summary.
References.
6. Managing Your Eclipse Environment.
An Overview of Your Eclipse Installation.
Understanding the Runtime Configuration.
Coordinating Preferences.
Understanding Configuration Management Fundamentals.
Interacting with the Update Manager.
Managing Your Configuration.
Chapter Summary.
Reference.
II. FUNDAMENTALS OF EXTENDING ECLIPSE.
7. Extending Eclipse for Fun and Profit.
Excited About Extending Eclipse? You Should Be!
An Easy and Practical Example.
A Brief Tour of "Hello, World".
Asking the Right Question Is More Important Than Knowing the Answer.
Where to Go from Here?
8. Overview of the Eclipse Architecture.
That Was Then, This Is Now.
Architectural Top Priorities: Extensibility and Integration.
Eclipse the IDE Platform and Rich Client Application.
The Eclipse Platform Runtime.
User Interface Frameworks.
Workbench Frameworks.
Chapter Summary.
References.
9. Getting Started: Plug-in Development.
Getting Started with Plug-ins.
Getting Started with Extensions and Extension Points.
Basic Steps of Implementing a Plug-in.
Using the Plug-in Development Environment.
Exercise Summary.
Chapter Summary.
References.
10. Creating Applications Using the Rich Client Platform.
Reasons Applications Are Being Built on the RCP.
Eclipse Architecture, Revisited.
Opportunities for Reuse of Eclipse.
Implementing Your Own Workbench.
Exercise Summary.
Chapter Summary.
References.
11. Creating Extension Points: How Others Can Extend Your Plug-ins.
Relationship Between Extension Points and Extensions.
Viewing the Official List of Enabled Plug-ins, Extensions, and Extension
Points.
How to Define Extension Points.
Handling Dynamic Plug-ins.
How to Enable the Schema-Based New Extension Wizard.
Example Summary.
Chapter Summary.
References.
12. Advanced Plug-in Development.
Migrating Your Plug-ins from Eclipse 2.1.
Plug-in Class Loader.
Runtime Discovery and Delayed Loading.
Forcing Early Plug-in Activation.
Plug-in Granularity.
Plug-in Fragments.
Chapter Summary.
References.
13. Defining Features and Products.
Features.
Products.
Exercise Summary.
Chapter Summary.
References.
III. EXTENDING THE ECLIPSE WORKBENCH.
14. The Standard Widget Toolkit: A Lean, Mean Widget Machine.
The Basic Structure of an SWT Application.
Common SWT Widgets.
Responding to Events.
How to Arrange SWT Widgets Using Layout Managers.
Error Handling.
Widgets Have Special Disposal Requirements.
Using Threads to Separate UI and Non-UI Activities.
An Overview of SWT Packages.
SWT Support for Swing.
Eclipse Forms.
Example Summary.
Chapter Summary.
References.
15. JFace Viewers.
Viewer Basics.
Viewer Framework.
Creating the Basic Content Viewer Arrangement.
Controlling the Content Displayed in a Structured Viewer.
Interacting with Viewer Objects.
Using Alternative Viewer Types.
Advanced Workbench Integration Options.
Example Summary.
Chapter Summary.
References.
16. Dialogs and Wizards.
Dialogs-The User Interface Beyond Workbench Parts.
Contributing to the Preferences Dialog.
Contributing to the Properties Dialog.
Contributing Wizards.
Directly Opening a Wizard Dialog for Your Wizard.
Example Summary.
Chapter Summary.
References.
17. Dialog Settings, Preferences, and User Settings.
Overview of the Options.
Storing Values in Dialog Settings.
Storing Preference Values for a Plug-in.
Scoped Value Management with User Settings.
Example Summary.
Chapter Summary.
References.
18. Views.
Views: The General-Purpose Workbench Part.
View Implementation.
Supporting Action Contributions.
Interacting with Other Workbench Components.
Examples Summary.
Chapter Summary.
References.
19. Editors.
Editor Behavior and Architecture.
Basic Implementation Steps.
Beyond the Basic Implementation Steps.
Example Summary.
Chapter Summary.
References.
20. Perspectives.
Creating a Perspective.
Using the perspectiveExtensions Extension Point.
Example Summary.
Chapter Summary.
Reference.
21. Action Contributions: The Integration Fast Track.
Action Contribution Extension Points.
The Fundamentals of Action Contributions.
Contributing to the Workbench Menu Bar and Toolbar.
Contributing to the View's Menu and Toolbar.
Contributing to an Editor's Menu and Toolbar.
Contributing Context Menus to Views and Editors.
Assigning Accelerator Keys to Your Actions.
Example Summary.
Chapter Summary.
References.
22. Providing Help.
Integrating Your Online Documentation.
Creating Context-Sensitive Help.
Running the Standalone Help Infocenter.
Customizing Your Help System.
Example Summary.
Chapter Summary.
References.
IV. EXTENDING THE ECLIPSE IDE.
23. Workspace Resource Programming.
Resource Concepts.
Workspace API.
Resource Properties.
Processing Workspace Resource Change Events.
Resource Modification Event Management.
Using Workspace Save Events to Save Critical Data.
Examples Summary.
Chapter Summary.
References.
24. Managing Resources with Natures and Builders.
Customizing Project Processing.
Defining and Implementing a Nature.
Defining and Implementing an Incremental Project Builder.
Example Summary.
Chapter Summary.
References.
25. Resource Tagging Using Markers.
Using Markers.
Adding New Marker Types.
Extending Markers with Generators for Resolution and Help Support.
Example Summary.
Chapter Summary.
References.
26. Building a Custom Text Editor with JFace Text.
Standard Text Editor Functions.
Editor Configuration: Customization Points.
Under the Covers of the Text Editor.
Example Summary.
Chapter Summary.
References.
27. Extending the Java Development Tools.
What Is the JDT and What Does It Do?
Java Model.
Accessing Reusable JDT Functionality.
Compiling Java Source Code.
Analyzing Java Source Code.
Manipulating Java Source Code.
Where the JDT Extends Eclipse.
Extending the JDT User Interface.
Examples Summary.
Chapter Summary.
References.
V. EXTENSIBILITY SPECIAL TOPICS.
28. Serviceability.
Plug-in Diagnostics: System and Configuration Information.
Eclipse Status Objects: A Status Collector.
Exception Handling: Error Detection.
Error Dialogs: Providing Detailed Status in Error Messages.
Runtime Tracing: A Runtime Diagnostic Tool.
Using Tracing in a Production Environment.
Diagnostics: A Comprehensive Error Log.
Error Logging: Writing to the Workbench Error Log.
Example Summary.
Chapter Summary.
Reference.
29. Implementing Responsiveness and Concurrency Using Jobs.
Concurrency Framework.
Using Jobs.
User Interaction Options.
Job Contention Management Options.
Example Summary.
Chapter Summary.
References.
30. Using Capabilities to Manage Too Much of a Good Thing.
Introducing Capabilities.
The Capabilities Extension Point.
Defining Primary Wizards.
The Activities API.
Defining Your Own Triggers.
Example Summary.
Chapter Summary.
References.
31. Internationalization and Accessibility.
What Does Internationalization Affect in Your Plug-in?
Internationalization Steps.
Accessibility.
Example Summary.
Chapter Summary.
References.
32. Performance Tuning.
Why Eclipse Should Start Quickly.
Diagnosing Startup Problems Using the Runtime Spy.
Case Study: Improving IBM WebSphere Studio's Startup.
Avoiding Performance Regressions Using the Performance Monitor.
Common Solutions to Eclipse-Specific Performance Problems.
Chapter Summary.
References.
33. Swing Interoperability.
Embedding AWT and Swing in Views and Editors.
Launch-and-Edit Integration.
ABCEditor Example-In-Process Invocation.
Example Summary.
Chapter Summary.
References.
34. OLE and ActiveX Interoperability.
COM Support in Eclipse.
COM Container Support.
OLE Automation-Accessing Extended Behavior.
Example Summary.
Chapter Summary.
Reference.
VI. EXERCISES.
Exercise 1: Using Eclipse.
Section 1: Your First Eclipse Project.
Section 2: Editors and Views.
Section 3: Working with Resources.
Section 4: Perspectives.
Section 5: Using Multiple Eclipse Windows and Workspaces.
Section 6: Getting Assistance.
Exercise Activity Review.
References.
Exercise 2: Using Java Development Tools.
Section 1: Hello World.
Section 2: Quick Fix.
Section 3: Code Generation.
Section 4: Refactoring.
Exercise Activity Review.
References.
Exercise 3: Running and Debugging Java.
Section 1: Launch Configurations.
Section 2: Debugging.
Section 3: Debugging II.
Section 4: Debugging Threads.
Section 5: Remote Debugging.
Exercise Activity Review.
References.
Exercise 4: Developing a Simple Web Commerce Application with Eclipse.
Exercise Setup.
Section 1: Setting up the Runtime Environment.
Section 2: Creating a Project for the Example.
Section 3: Debugging the Example.
Section 4: Deploying the Example.
Exercise Activity Review.
References.
Exercise 5: Working as a Team with CVS.
Exercise Setup.
Section 1: Getting Started.
Section 2: Updating, Committing, and Resolving Conflicts.
Section 3: Branching and Merging.
Exercise Activity Review.
Reference.
Exercise 6: Developing Your First Plug-in.
Exercise Setup 954Section 1: "Hello, World" in Five Minutes
or Less.
Section 2: "Hello, World" with Detailed Step-by-Step Instructions.
Section 3: Testing with the Runtime Workbench.
Section 4: Debugging with the Runtime Workbench.
Section 5: Defining a Feature to Support the Plug-in.
Section 6: Deploying a Feature and Its Associated Plug-ins.
Section 7: Exploring (and Sometimes Correcting) the Eclipse Platform Code.
Section 8: Correcting Common Problems.
Exercise Activity Review.
Exercise 7: Developing Your First Rich Client Application.
Exercise Setup.
Getting Started.
Section 1: Creating an Application Extension.
Section 2: Creating a Perspective Extension.
Section 3: Creating a Workbench Advisor.
Section 4: Implementing the Application's Main Program.
Section 5: Running and Testing Your RCP Application.
Section 6: Configuring Workbench Window User Interface Elements.
Section 7: Adding Menu and Toolbar Actions.
Section 8: Deploying Your Application.
Section 9: Adding "Optional" Components.
Exercise Activity Review.
Exercise 8: Developing a Rich Client Application with Dynamically Added
Plug-ins.
Exercise Setup.
Section 1: Create Your RCP Application Launch Configuration.
Section 2: Implement Your Plug-in Life Cycle start() Method.
Section 3: Implement Your Configurator.
Section 4: Develop a Simple Plug-in Discovery Mechanism.
Section 5: Installing the Bonus Pack Dynamically.
Exercise Activity Review.
Exercise 9: Deploying Your Product Using Features.
Exercise Setup.
Section 1: Tasks of a Feature Developer.
Section 2: Tasks of an Eclipse User.
Section 3: Tasks of a Product Developer.
Section 4: Tasks for a Product Service Team-Implementing an Update Site.
Section 5: Tasks of an Eclipse User-Redux.
Exercise Activity Review.
Index.
About the Authors
Jim D'Anjou is a Senior Software Engineer at the IBM Silicon
Valley Lab in San Jose, California. He has a degree in Computer Science from
the University of California, Berkeley. Jim has over 25 years of industry experience
at IBM and elsewhere. He has held a variety of technical and management positions
in development of products for relational database, database tools, application
repositories, and application development tools. He holds two U.S. patents for
work in software process automation. In March 2001, he joined the Eclipse Jumpstart
team where his focus is on Team support. Jim works with repository ISV's who
are enabling to the Eclipse Platform.
Scott Fairbrother is an Advisory Software Engineer at IBM in
Research Triangle Park, North Carolina. Scott is a software developer with over
20 years of experience. He has developed object-oriented application frameworks
for business process management. He has written specifications for IBM middleware
on Windows 2000 and has also authored on the subject of Microsoft Visual Studio
.NET. Most recently, Scott has worked on the Eclipse Jumpstart team, helping
IBM and partners create commercial offerings based on Eclipse. He received a
B.S. in Marine Biology from the University of North Carolina at Wilmington in
1978.
Dan Kehn is a Senior Software Engineer at IBM in Research Triangle
Park, North Carolina. His interests in object-oriented programming go back to
1985, long before it enjoyed the acceptance it has today. He has a broad range
of software experience, having worked on development tools like VisualAge for
Smalltalk, operating system performance and memory analysis, and user interface
design. Dan worked as a consultant for object-oriented development projects
throughout the U.S. as well as four years in Europe. His recent interests include
object-oriented analysis/design, programming tools, and Web programming with
the WebSphere Application Server. In May 2001, he joined the Eclipse Jumpstart
team, whose primary goal is to help ISVs to create commercial offerings based
on the Eclipse Platform.
John Kellerman joined IBM in 1984 with a computer science degree
from Purdue University. He's since completed graduate degrees in Computer Engineering
at North Caroline State and Business Administration at the University of North
Carolina, Chapel Hill. He has spent the majority of his 19 years at IBM in the
development and management of application development tool products, including
ISPF/PDF, VisualAge Smalltalk, VisualAge Generator, and Eclipse. John was a
founding member of the Eclipse project, which got under way in late 1999. He
is currently IBM Product Manager of Eclipse. His responsibilities include working
closely on behalf of IBM with eclipse.org and the member companies to help grow
the Eclipse community of contributors and commercial offerings.
Pat McCarthy, a Senior Programmer with IBM, is a specialist
in the use and management of development technologies on a variety of runtime
platforms. Pat's IBM career has included hands on development of business application
systems in Poughkeepsie NY, 12 years of project management for the development
of IBM Redbooks and education offerings in San Jose, CA. During the last several
years in Raleigh, NC, he has focused on supporting the use of Eclipse technology
in IBM application development products. Pat has a B.S. from Indiana University
of Pennsylvania (IUP), an M.S. from Marist College, and is the co-author of
more than 20 IBM Redbooks.
|
