01 Contributing to Eclipse: understanding and writing plug-ins
Kai-Uwe Maetzel, Tom Eicher
Eclipse was designed from the ground-up with extensibility in mind. A scalable plug-in mechanism and a rich set of APIs enables developers to develop and explore new tools quickly, without having to start from scratch.

This tutorial illustrates the full plug-in development cycle by way of an example. You'll explore the Eclipse architecture and become familiar with the basic plug-in mechanism. With this knowledge, you'll write and debug your first plug-in using Eclipse's Plug-in and Java Development Environments. You'll also add extension points to your plug-in to enable others to extend it. You will then package your extensible plug-in as a Feature and publish it with the built-in Eclipse Update Mechanism. Finally, you'll set up and manage an Eclipse Update Site, a place for other Eclipse users to explore new features as well as finding upgrades. After having successfully delivered your first plug-in, you'll learn how to apply the proven technique of unit testing to Eclipse plug-ins. You'll write plug-in unit tests for your additions to Eclipse as well as for your code that handles the extension points defined in your plug-in. You'll also learn how to transform your plug-in into a stand-alone Eclipse RCP.

During all these steps, you will learn the underlying Eclipse concepts and design ideas. You'll learn the rules you need to know to make your plug-ins good Eclipse citizens. In addition, you will receive many interesting insights on design challenges in large scale plug-in architectures.

Tutorial participants are invited to bring their laptops and deepen their understanding by implementing practical exercises.

Download the Presentation File
Regency A 8:30 - 5:30Monday, Feb. 28th

02 Workbench and JFace Foundations
Michael Van Meekeren, Tod Creasey
This tutorial will teach the foundations of the Workbench and JFace to developers with limited experience in this area of plug-in development. Attending this tutorial will act as preparation for the Advanced Workbench and JFace and/or the RCP follow on tutorials. This session will give an introduction to the components of the Workbench, such as (views, wizards and menus) writing sample code along the way. At the end of this session attendees will have built a set of samples that exercise the various building blocks of the Workbench and JFace.
Download the Presentation File
Regency C 8:30 - 12:30Monday, Feb. 28th

03 Getting Started with Eclipse
Dwight Deugo
This tutorial is for people that have not yet worked with Eclipse. You'll explore Eclipse's architecture and become familiar with the plug-in mechanism. We will start with an overview of Eclipse and how to install and run it. Next, we will describe Eclipse's Workbench and its resources, views and perspectives. Next we will examine Eclipse's Java Development Tools that implement a Java IDE supporting the development of Java applications and plug-ins. We will then focus on how testing and debugging is done in Eclipse. Finally, we will introduce Eclipse's architecture and how it supports plug-ins.
Download the Presentation File
Sandpebble C 8:30 - 12:30Monday, Feb. 28th

04 Using the Test and Peformance Tools Platform (TPTP)
Eugene Chan, Guru Nagarajan
How to do performance profiling of local and remote Java applications using the TPTP trace and performance tools.

This session will focus on using the TPTP tooling inherited from Hyades to do Java performance profiling. A complete walk through from running the monitored program to analysis using each of the views will be covered.

Download the Presentation File
Grand Peninsula ABCD 8:30 - 12:30Monday, Feb. 28th

05 Introduction to SWT
Carolyn MacLeod, Grant Gayed
The Standard Widget Toolkit is a Java class library for creating graphical user interfaces. It was created as part of the Eclipse project to facilitate the building of efficient, portable applications that directly access the operating system's user interface facilities. We will provide a guided tour of the toolkit by breaking the task of building a graphical user interface-based application into component parts, and showing how these are modeled in SWT through a series of examples. Bring your laptop with a working install of Eclipse on it, and follow along as we explore how SWT can be used to create user interfaces for Java applications.
Download the Presentation File
Sandpebble D 8:30 - 12:30Monday, Feb. 28th

06 Building a Custom Test Execution Environment
Joe Toomey, Sri Doddapanenni
This session will describe how to build a custom test execution environment ---TPTP provides a platform for defining and managing tests and their associated execution histories. This framework has been extended for JUnit, URL and manual testing. Each of these will be demonstrated to explain the framework, and then a sample new execution environment will be introduced.
Download the Presentation File
Sandpebble A 8:30 - 12:30Monday, Feb. 28th

07 Eclipse Concurrency in Action
Michael Valenta, John Arthorne
The session begins with a brief overview of APIs in Eclipse 3.0 that help plug-ins increase the concurrency and UI responsiveness of their applications. Next, participants get their hands wet by working with a concrete example. We provide a simple plug-in that is unresponsive and blocks the user excessively. Participants are given the task of making the plug-in more responsive using jobs, the workbench progress service, and related APIs. Implementations are then reviewed and discussed. The session ends with a presentation on further pitfalls of increasing concurrency, and best practices for improving application responsiveness safely and effectively.
Download the Presentation File
Bayside A&B 8:30 - 12:30Monday, Feb. 28th

08 Developing Eclipse Rich-Client Applications
Christian Wege, Frank Gerhardt
In this tutorial we describe the overall architecture of an RCP application and its specific components. Participants will learn and perform the steps to build their own RCP application. We will show how to develop a minimal application plug-in, add a feature including custom branding, and package the application for deployment. We will show how to deliver updates using an update site and the update manager. We test our sample RCP application using PDE JUnit and demonstate how test-driven development works with RCP. We cover running the JUnit tests from an Ant script as part of a nightly build.
Download the Presentation File
Harbor Room A 8:30 - 12:30Monday, Feb. 28th

09 Enterprise AspectJ Tutorial using Eclipse
Ron Bodkin, Ramnivas Laddad
Aspect-oriented programming (AOP) has become a hot topic for enterprise development, with recent news of support by IBM, BEA, JBoss, and others. Behind the headlines, however, are critical questions:
  • How real is AOP for the enterprise?
  • What problems can it solve today?
  • How does it apply to enterprise applications?
  • How can one make an informed decision about trying to use AOP?
  • What is the best adoption strategy?
  • What are the long term possibilities?
This tutorial provides answers to these and provides a hands-on introduction to AOP. Attendees apply AOP to solve a range of problems in enterprise Java application development, such as publishing business events, testing, error handling, and persistence mechanisms. Exercises are done using lightweight Java technologies such as Spring and Hibernate in a J2EE container. Attendees gain a real understanding of how AOP works, how it can be useful, and how to work with AOP and the available tools. Attendees learn AOP design patterns, best practices, and are in a good position to start applying the technology.
Download the Presentation File
Sandpebble E 8:30 - 5:30Monday, Feb. 28th

10 Aspect-Oriented Programming with AspectJ
Andy Clement, Mik Kersten
Heard about aspect-oriented programming, but haven�t had the time to try it out? This tutorial is for you. Following the principle that the best way to learn is by doing, this introductory tutorial is packed with hands-on exercises that will teach you the fundamentals of AspectJ using the latest AspectJ Development Tools (AJDT) plugin for Eclipse.
Download the Presentation File
Harbor Room B 8:30 - 12:30Monday, Feb. 28th

11 Models to Code with the Eclipse Modeling Framework
Ed Merks, Dave Steinberg
This tutorial will describe and demonstrate EMF, showing how it brings the benefits of modeling to the mainstream programmer and how EMF and modeling facilitate data sharing and application integration. The tutorial will also give a brief overview of modeling and MDA (Model Driven Architecture) and explain how EMF provides a middle ground between modeling and programming that maximizes the effectiveness of both.
Download the Presentation File
Grand Peninsula ABCD 8:30 - 12:30Monday, Feb. 28th

12 Introduction to the Web Tools Platform
Chuck Bridgham, Lawrence Mandel
The Web Tools Platform (WTP) project's mission is to provide a common framework for building Web tools for Eclipse and to provide both standard and Java Web tools that build upon the common framework. In this tutorial you will learn how to use the WTP project's end user tools which include tools for data access, server control, Web project (including Web services) creation, and testing.
Download the Presentation File
Grand Peninsula ABCD 8:30 - 12:30Monday, Feb. 28th

20 Advanced UI Development in the Eclipse Workbench
Michael Van Meekeren, Tod Creasey
This tutorial will be a follow on session for "Workbench and JFace Foundations", however "Workbench and JFace Foundations" is not required for developers with sufficient Eclipse experience. While the Foundations session gives an introduction to the components of the Workbench, this session will apply what was learned in the first session in building an application that is tightly integrated with the Eclipse IDE using many key features of the Workbench. At the end of this session attendees will have created an application, based on the Workbench and JFace, that tightly integrates into the Eclipse IDE.
Download the Presentation File
Regency C 1:30 - 5:30Monday, Feb. 28th

21 The Eclipse Debug Framework
Bjorn Freeman-Benson, Darin Wright
In this talk, we demonstrate how to use the Eclipse debugging framework to add debugger support to the Eclipse IDE. We use a small assembly language as our example, but the lessons and techniques apply to languages and applications of all complexities. We demonstrate that larger application as well by showing a few of the details of three other Eclipse debuggers: the Eclipse JDT debugger, a visual language debugger, and a debugger for an urban simulation application. This talk is based on our papers published on the Eclipse.org website: "How to write an Eclipse debugger" and "Enhancing the Eclipse debugger".
Download the Presentation File
Bayside A&B 1:30 - 5:30Monday, Feb. 28th

22 Using TPTP Logging and Monitoring tools
Antony Miguel, Paul Slauenwhite
This tutorial describes how to use the Logging and Log View/Analysis tools in the Test and Performance Tools Platform (TPTP). The logging framework in TPTP can be used for simple logging, but it can also feed a significant but simple set of tooling that can help minimize the task of analyzing logs regardless of who produced them. The framework and the log analyzer tooling will be explained and demonstrated.
Download the Presentation File
Sandpebble C 1:30 - 5:30Monday, Feb. 28th

23 GEF In Depth
Randy Hudson, Pratik Shah
The Graphical Editing Framework (GEF) uses an SWT-based lightweight GUI toolkit to provide a feature-rich framework for creating graphical editors in Eclipse. GEF is application neutral and provides the groundwork to build almost any application, including, but not limited to, charts and graphs, reports, activity diagrams, GUI builders, UML diagram editors, and even WYSIWYG text editors like HTML.

This tutorial will provide an in-depth look at GEF and some hands-on experience by walking you through the creation of a GEF-based plug-in involving shapes, connections, textual cell-editors, palette, outline, property sheet, overview, printing support and so on. You will also learn of best practices and common pitfalls to avoid. Time-permitting, you will learn how to hook into other GEF features such as rulers and guides, snapping, and/or zoom.

This tutorial is intended for developers who have a working knowledge of the Eclipse workbench, SWT, plug-in development, but have little or no GEF experience. The preceding "Workbench and JFace Foundations" tutorial should provide the necessary skills. Attendees are encouraged to bring a laptop.

For more information about GEF, please visit our website: http://history.eclipsecon.org/gef

Download the Presentation File
Grand Peninsula ABCD 1:30 - 5:30Monday, Feb. 28th

24 Creating, Packaging, Testing and Deploying Features in Eclipse 3.0
Sandy Minocha, Pat McCarthy
A feature is a way of grouping and describing different functionality that makes up a product. Grouping plug-ins into features allows the product to be installed and updated using the Eclipse update server and related support. Features do not contain any code. Because there are a number of different tools that support the creation and packaging of features and multiple options exist for deploying features, it can be difficult to work with features. The objective of this tutorial is to demonstrate the various tools in Eclipse for building features and present use cases for deploying features.
Download the Presentation File
Sandpebble D 1:30 - 5:30Monday, Feb. 28th

25 Eclipse Distilled: A Quick Start to Agile Development
David Carlson
This tutorial is for Java developers who are new to Eclipse or would like a deeper understanding of its use. It does not cover the plug-in architecture or how to program plug-ins, but everything in this tutorial is essential knowledge for someone writing plug-ins. You�ll learn how to customize workspaces, projects, perspectives, and views for optimal efficiency, and how to leverage agile development tools built into Eclipse, such as team ownership with CVS, refactoring, continuous testing, continuous integration, and coding standards. This is a hands-on tutorial where you will setup several Java projects and work through an example of building a product catalog application.
Download the Presentation File
Sandpebble B 1:30 - 5:30Monday, Feb. 28th

26 Developing for the Rich Client Platform
Nick Edgar, Pascal Rapicault
This tutorial will be a follow on session for �Workbench and JFace Foundations�, however �Workbench and JFace Foundations� is not required for developers with sufficient Eclipse experience. The Rich Client Platform introduced in Eclipse 3.0 makes the rich set of functionality in Eclipse available for building arbitrary applications, not just development tools. This session will explain, through a running example, all aspects of building an RCP application that is separate from the Eclipse IDE, including topics such as structuring plug-ins, product branding, use of optional components such as Help and Update, UI customization, and deployment. At the end of this session attendees will have created and deployed a complete RCP application.
Download the Presentation File
Grand Peninsula ABCD 1:30 - 5:30Monday, Feb. 28th

27 Visual Editor tutorial
Gili Mendel, Joe Winchester
The Eclipse Visual Editor allows you to graphically create and edit a Java GUI that uses either Swing or SWT widgets. It is built using an extensible framework and the tutorial shows how to extend the VE to contribute to the palette, support new layout managers, add new custom widgets, new property editors, new customizers and leverage flexible code generation patterns.
Download the Presentation File
Sandpebble A 1:30 - 5:30Monday, Feb. 28th

28 Mastering Eclipse Modeling Framework
Vladimir Bacvanski, Petter Graff
This tutorial teaches the participants how to use and extend the Eclipse Modeling Framework (EMF). Using a set of case studies, the participants master the EMF framework as a generative tool for model driven development. The tutorial explores all aspects of EMF development, from creation of models for EMF, use of generators and concluding with Java Emitter Templates for Java code generation.
Download the Presentation File
Harbor Room B 1:30 - 5:30Monday, Feb. 28th

29 Java Tool Smithing - Extending the Eclipse Java Dev. Tools
Martin Aeschlimann, Dirk Baeumer, Jerome Lanneluc
The Java development tools (JDT) contribute a set of plug-ins for Java development to Eclipse. Like the Eclipse Platform, the JDT is designed to be extended so you can add your own functionality and become a JDT tool smith. This half-day tutorial will teach you how to use the Eclipse Java API and extension points to contribute to the Java tooling. In addition, the tutorial will give insights into recent improvements to the JDT including support for J2SE 5.0 (generics and annotations) and Java-like languages, embracing non-Java files containing references to Java language elements, and participating in refactoring operations.

Besides consuming the expected "slide show" participants will work on concrete examples as well. So bring your laptop with a working install of Eclipse (3.01 or higher) on it to get your "hands" wet by extending JDT.

Download the Presentation File
Harbor Room A 1:30 - 5:30Monday, Feb. 28th