Eclipse Lives In Winnipeg

Debug Top-level Toolbar

2011-10-12T11:18:00.004-05:00

Recently the platform debug team has been working on a new idea for debug-view-less debugging. We have come up with the idea of a top-level toolbar for the common debug commands; so (in theory) you can debug with needing the debug view front and center of your current perspective. The new toolbar can be activated from within the debug view using the View Menu > Debug Toolbar menu item.

The root Eclipse bug for the enhancement is bug 258767

We have already found lots of room for improvement:
bug 359151, bug 264485, bug 360172, bug 360636 and bug 360637

So for all those interested in the debug-view-less debugging idea, please spend some time and try out the new toolbar, just remember to file bugs!

The toolbar look and feel:

Debugging Ant Tasks with Self Hosting

2011-01-14T16:12:00.000-06:00

Do you know that Eclipse Ant support has debugging capabilities?

If not, check out this tutorial to get started.

Do you know how to self-host with Eclipse to test plug-ins?

If not here is a quick overview.

To debug ant tasks in a self hosted environment, the tasks must be included in a plug-in project. If you are working with tasks outside of a plug-in development scenario, you can use remote debugging instead. Here is a blog post to get you started.

Scenario:

You are developing an ant task to be included in an Eclipse plug-in. You have the java code to execute the task in a plug-in that defines the task as an ant task extension in the plug-in xml. The task runs, but the output is a bit off. Time to start debugging.

1) Start a runtime workbench

Same as you would when debugging any other plug-in.

2) Create a new ant script

It doesn't matter what kind of project you put the script in.

Fill in the script with the proper targets and properties. When calling your tasks, you will have to put in their full name as defined in the org.eclipse.ant.core.antTasks extension. When running from a built jar, just the name of the class is satisfactory, but when self hosting we need the full name.

3) Create a new ant launch configuration

Right click on the script and hold down Ctrl while clicking "Debug > Ant Script". You can also open the launch config dialog from the main menu, "Run > External Tools > External Tools Configurations".

4) Set up configuration options

Give the configuration a name. On the JRE tab, select "Run in the same JRE as the workspace". If you don't change this option, debugging won't work correctly.

5) Run the configuration

If there is a problem running the task, check that you have the full name of the task written in. You can also check that Ant knows about your task by looking on the Ant > Runtime preference page (the Tasks tab will list all known tasks).

6) Start debugging

Set some breakpoints in the host workspace. Make sure you debug your ant script (not just run it).

Note: Hot Code Replace does not work when debugging this way as the jar containing the tasks must be rebuilt.

Weird SVN State

2010-10-20T10:15:00.004-05:00

Today when I got to work and tried to sync a pile of my projects, I was met with the following exception (and a cute dialog telling me the same thing, but without as many red X's):

org.eclipse.team.svn.core.connector.SVNConnectorException: svn: '/home/mrennie/workspaces/workspace/CommandLineDebugger' is not a working copy
svn: Cannot read from '/home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format': /home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format (No such file or directory)
at org.polarion.team.svn.connector.svnkit.SVNKitConnector.handleClientException(SVNKitConnector.java:1400)
at org.polarion.team.svn.connector.svnkit.SVNKitConnector.status(SVNKitConnector.java:337)
at org.eclipse.team.svn.core.extension.factory.ThreadNameModifier.status(ThreadNameModifier.java:608)
at org.eclipse.team.svn.core.operation.local.RemoteStatusOperation$2.run(RemoteStatusOperation.java:147)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doSubTask(ProgressMonitorUtility.java:118)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.protectStep(AbstractActionOperation.java:154)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.protectStep(AbstractActionOperation.java:149)
at org.eclipse.team.svn.core.operation.local.RemoteStatusOperation.runImpl(RemoteStatusOperation.java:145)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.run(AbstractActionOperation.java:81)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTask(ProgressMonitorUtility.java:104)
at org.eclipse.team.svn.core.operation.CompositeOperation.runImpl(CompositeOperation.java:95)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.run(AbstractActionOperation.java:81)
at org.eclipse.team.svn.core.operation.LoggedOperation.run(LoggedOperation.java:39)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTask(ProgressMonitorUtility.java:104)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTaskExternal(ProgressMonitorUtility.java:90)
at org.eclipse.team.svn.core.synchronize.AbstractSVNSubscriber.findChanges(AbstractSVNSubscriber.java:314)
at org.eclipse.team.svn.core.synchronize.AbstractSVNSubscriber$UpdateStatusOperation$2.run(AbstractSVNSubscriber.java:349)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doSubTask(ProgressMonitorUtility.java:118)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.protectStep(AbstractActionOperation.java:154)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.protectStep(AbstractActionOperation.java:149)
at org.eclipse.team.svn.core.synchronize.AbstractSVNSubscriber$UpdateStatusOperation.runImpl(AbstractSVNSubscriber.java:347)
at org.eclipse.team.svn.core.operation.AbstractActionOperation.run(AbstractActionOperation.java:81)
at org.eclipse.team.svn.core.operation.LoggedOperation.run(LoggedOperation.java:39)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTask(ProgressMonitorUtility.java:104)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTaskExternal(ProgressMonitorUtility.java:90)
at org.eclipse.team.svn.core.utility.ProgressMonitorUtility.doTaskExternal(ProgressMonitorUtility.java:81)
at org.eclipse.team.svn.core.synchronize.AbstractSVNSubscriber.refresh(AbstractSVNSubscriber.java:186)
at org.eclipse.team.svn.core.synchronize.UpdateSubscriber.refresh(UpdateSubscriber.java:73)
at org.eclipse.team.core.subscribers.Subscriber.refresh(Subscriber.java:466)
at org.eclipse.team.core.subscribers.SubscriberMergeContext.refresh(SubscriberMergeContext.java:85)
at org.eclipse.team.core.mapping.provider.SynchronizationContext.refresh(SynchronizationContext.java:109)
at org.eclipse.team.internal.ui.synchronize.RefreshModelParticipantJob.doRefresh(RefreshModelParticipantJob.java:69)
at org.eclipse.team.internal.ui.synchronize.RefreshParticipantJob.run(RefreshParticipantJob.java:309)
at org.eclipse.team.internal.ui.synchronize.RefreshModelParticipantJob.run(RefreshModelParticipantJob.java:117)
at org.eclipse.core.internal.jobs.Worker.run(Worker.java:54)
Caused by: org.tigris.subversion.javahl.ClientException: svn: '/home/mrennie/workspaces/workspace/CommandLineDebugger' is not a working copy
svn: Cannot read from '/home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format': /home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format (No such file or directory)
at org.tigris.subversion.javahl.JavaHLObjectFactory.throwException(JavaHLObjectFactory.java:724)
at org.tmatesoft.svn.core.javahl.SVNClientImpl.throwException(SVNClientImpl.java:1929)
at org.tmatesoft.svn.core.javahl.SVNClientImpl.status(SVNClientImpl.java:304)
at org.tmatesoft.svn.core.javahl.SVNClientImpl.status(SVNClientImpl.java:282)
at org.polarion.team.svn.connector.svnkit.SVNKitConnector.status(SVNKitConnector.java:334)
... 33 more
Caused by: org.tmatesoft.svn.core.SVNException: svn: '/home/mrennie/workspaces/workspace/CommandLineDebugger' is not a working copy
svn: Cannot read from '/home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format': /home/mrennie/workspaces/workspace/CommandLineDebugger/.svn/format (No such file or directory)
at org.tmatesoft.svn.core.internal.wc.SVNErrorManager.error(SVNErrorManager.java:64)
at org.tmatesoft.svn.core.internal.wc.admin.SVNAdminAreaFactory.open(SVNAdminAreaFactory.java:149)
at org.tmatesoft.svn.core.internal.wc.admin.SVNWCAccess.doOpen(SVNWCAccess.java:355)
at org.tmatesoft.svn.core.internal.wc.admin.SVNWCAccess.open(SVNWCAccess.java:263)
at org.tmatesoft.svn.core.internal.wc.admin.SVNWCAccess.open(SVNWCAccess.java:256)
at org.tmatesoft.svn.core.internal.wc.admin.SVNWCAccess.openAnchor(SVNWCAccess.java:151)
at org.tmatesoft.svn.core.wc.SVNStatusClient.doStatus(SVNStatusClient.java:320)
at org.tmatesoft.svn.core.javahl.SVNClientImpl.status(SVNClientImpl.java:300)
... 35 more

After swearing for a bit and asking Google what I should do (and having no luck) I tried deleting suspicious looking files from the /.svn folder located in each affected project. The winner - at least for me - was to delete the /.svn/tmp folder and all of its contents and then restart Eclipse. After that all is well and I can sync to my hearts content.

I filed a bug for this state problem here:
https://bugs.eclipse.org/bugs/show_bug.cgi?id=328258

How p2 based targets work

2010-09-15T13:38:00.002-05:00

Software Site locations in Target Definitions, typically described as "p2 based targets" are targets that get their bundles from an update site or p2 repository. This article will go over some of the implementation details of these targets. Knowing how the bundles are downloaded and added to the target can help to reproduce bugs and find workarounds.

For more general information on Target Platforms, see my previous article. The Eclipse help doc also explains a lot about how to create p2 based targets and add content to them.

The Basics:

Target definitions are created using the preference page or the editor. To create a p2 based target, at least one 'software site' location must be added to the target. The actual site location is abstracted from PDE. A local zipped repo, a remote site or a local profile will all be treated the same. A software site location specifies a site (or a category such as "all available sites") as well as one or more Root IUs. The root IUs describe what is being downloaded from the site, they are often high level features that effectively group a collection of bundles.

Target definitions must be resolved to modify the bundle list on the content tab or to set one as the active target platform. The resolve operation runs for each location independently. For most locations the resolve simply scans the location to get a list of file locations for bundles. In the case of a software site location, a more complex operation must be run.

Resolving Software Sites:

For each software site location, the following steps are taken:

Load the repositories. This will create a queryable repository object. p2 will often request a repo's contents.xml file.
Get the root IUs. If the location didn't already have actual installable units for the root units, the root IUs will be obtained from the site.
Setup the planner or slicer. More on this later.
Create a profile.
Run the operation. Downloads and installs the units into the profile.
Collect bundle locations for the target platform.

Note: In 3.7 a new performance enhancement was added that will skip the above steps and instead attempt to get a list of bundles from the stored profile. If the profile doesn't contain all the expected bundles or a problem occurs, the operation reverts to following the above steps.

Important Locations:

The following directories describe where PDE/p2 stores information related to the target resolution. Those familiar with p2 can modify the contents of the directories to force things to be recreated or to use the contents for a special purpose.

Target Definition Files:
/.metadata/.plugins/org.eclipse.pde.core/.local_targets
Where PDE stores the targets it creates from the preference page.

Profile Location:
/p2/org.eclipse.equinox.p2.engine/profileRegistry
Where profiles are created and persisted

Bundle Pool:
/.metadata/.plugins/org.eclipse.pde.core/.bundle_pool
Where p2 will download the bundles to during the operation

Planning vs Slicing

Once we have one or more sites and root IUs, we run a provisioning operation to download the required bundles and install them into a profile. The operation can be done using a slicer, which is typically used for mirroring a site or a planner, which is used by Eclipse to safely install and update itself.

Which one to use is determined by the options at the bottom of the wizard when editing a software site location. If "Include required software" is checked the planner is used. If unchecked the slicer is used. The include all environments setting determines if environment properties are set on the slicer.

The planner behaves the same as though we were installing the root IUs into an application. Therefore it checks that the complete set of required IUs are available to be downloaded and installed. If any IU is missing, the planner will report an error saying that a requirement is missing. This can be convenient as you may not realize some important piece is missing from your target. However, the target does not need to be a complete, runnable install, so forcibly requiring everything may be optimal.

The slicer uses an operation that copies IUs from a remote site to a local location. The slicer does create a list of required IUs, however it does not fail if the requirements are missing. Instead it will download all requirements it can from the site or sites that have been provided. This is a lot more flexible than the planner as all available IUs (even IUs that don't apply to the current environment settings) will be downloaded.

Conclusion:

After the resolve operation is complete, a list of bundles will be returned (pointing to the local copies in the bundle pool). PDE will use the local bundles as the target.

What is a Target Platform

2010-09-15T10:57:00.007-05:00

The current Target Platform in PDE is very important to anyone developing bundles in Eclipse. Whether you are developing SDK Plug-ins, an RCP product or a OSGi application, managing the contents of your target platform is important.

So what is a target platform?

At its core, a target platform is a collection of plug-ins (aka bundles) that PDE can use to compile against, launch with, lookup information in and more. When developing a bundle it is almost guaranteed that you will depend on other bundles. While you can have the complete required set of bundles in your workspace, it clutters the navigator views and degrades performance. The target platform provides an easy way to manage the bundles you build against.

The target platform is used for the following in PDE:

Compile - Plug-ins in the workspace are built against the target platform so you do not have to have everything in your workspace
Launch - When using PDE's launchers you can choose the set of plug-ins you want to launch. By default the Eclipse Application Launcher will start with all plug-ins in the target, but will use workspace plug-ins instead when available
Calculate Dependencies - PDE assists you in finding the plug-ins your plug-ins was include/require to compile correctly by looking at what is available in the target platform

Where do I edit the target platform?

The target platform is managed on the PDE > Target Platform preference page. When you go to that page (3.5 and later) you will see a list of all the target definitions you have available with the current target platform bolded. PDE only has a single active target platform that all bundles in the workspace use (this might change someday).

However, you can have multiple target definitions. A target definition describes the contents of a target. You can select any target definition as the target platform and that is what PDE will build against. For users who only build one product, you only need to create and modify a single definition, but users who develop different applications (or different versions of the same application) in the same workspace will find that having multiple target definitions makes it easy to switch modes.

How do I create a target?

To get started, go to the preference page and hit add to create a new target. There are some options to create targets from existing templates, but for now select Nothing and hit next.

There are many options when setting up a target, but only a few are needed for basic setups. The first step is to give the target definition a name so we can recognize it later.

The important parts of a target definition is its locations and its content. The locations define where the target should find bundles, the content defines which bundles from the location to take.

On the locations tab you can add 4 types of locations. A directory will just collect any bundles found in the directory you point it to. An installation will treat the location as an Eclipse application. Rather than just looking in a directory, the installation location will consider link folders, a platform.xml if the app uses update manager, or a bundles.info file if the app uses p2 (simple configurator). A feature location will add a single feature and its included bundles to the target. Finally, a software site location will allow bundles to be retrieved from a local or remote update site or p2 repository.

The content tab is only important if you need to limit the bundles in the target. For plug-in developers this step is unecessary, but for RCP developers it can be more important. This article explains the reasoning. The content tab will list all the bundles in the target, along with check boxes to remove them. The tab also provides a number of ways to filter the list so you can quickly remove certain types.

One internal detail that target platform users may want to know is that when bundles are unchecked, the remaining list of bundles is stored as an include list, independant of the locations. This was a change from the <3.5 style="font-style: italic;">share button on the preference page. You can also create a new target definition file in the workspace using File > New. The target files can be added to a version control system and shared among team members.

What other features use targets?

The Target Platform State View can be used to see what is in your target.
Add new content to your target on the fly.
You can export the contents of your target platform.
Manage your target contents using features.
Add the target platform to the java search path.

What is in the future for targets?

In 3.7 there have been multiple improvements around software site (p2) based targets, including improved resolution performance and better offline support. PDE's API Tooling features already leverage some of the target code, but hopefully in the near future there will be even better integration.

Expect another blog post soon explaining more about how p2 targets work.

"Add new expression" inline in Expressions View

2010-05-13T12:20:00.004-05:00

The debugger expressions view has a new feature: the ability to add a new expression without opening a dialog. When user clicks on "Add new expression" entry, a cell editor is activated to enter the new expression.

I hope most people will appreciate this little convenience but since introducing it few months ago I got one complaint and a request to make it optional. What do you think? Is it worth adding yet another preference to try to make everyone happy?

API Use Reports

2009-09-16T12:13:00.007-05:00

It's no longer rocket science - mere mortals can create API Use Reports using Eclipse 3.6 M2. Report generation is integrated as an external tool. Simply open the External Tools dialog (Run > External Tools > External Tools Configurations...), create a new "API Use Report" configuration, tweak settings, and press "Run".

You have to specify:

The bundles to analyze (which can be provided as an API baseline, a PDE target definition, or simply as a directory)
Whether to report API and/or internal references
Optionally, the scope to analyze (use regular expressions to include bundles to search and bundles you are interested in references to, or leave blank to scan everything)
A directory to write the report in

In this example, I ran a report for API & internal references in one of the M2 warm up builds. I only included references between org.eclipse.* bundles. What does it show? Lots of stuff.

3.6 PDE plan ideas

2009-07-21T11:47:00.001-05:00

We have updated our PDE 3.6 plan ideas page here : http://wiki.eclipse.org/PDE/Plan/3.6 so check it out...feedback is always welcome.
Sent on the TELUS Mobility network with BlackBerry

Breakpoints Not Being Hit?

2009-06-11T11:59:00.001-05:00

Just wanted to bring attention to an issue discovered with Sun’s recently released 1.6.0_14 virtual machine. Breakpoints are unreliable - i.e. do not always suspend execution. The problem occurs on Windows and Linux platforms. The associated Eclipse bug is:

https://bugs.eclipse.org/bugs/show_bug.cgi?id=279137

At this point, it appears to be an issue with the VM rather than Eclipse. The workaround is to use the 1.6.0_13 virtual machine.

Target Platforms in 3.5

2009-05-01T09:45:00.007-05:00

What a milestone for PDE. Chris has been blogging away about things in M7, and I wanted to talk a little more about the target platform changes coming in M7.

When I started work on PDE UI, this is all I knew about target platforms...

Talk about button overload. So many features, none of which I ever had touched as a debug plug-in developer. I didn't like the UI, I was confused by the 'model' that backed it, and touching anything on that page seemed to break someone (or everyone).

Fortunately, in 3.5 the PDE UI team: Chris A, Darin W, and myself along with Ankur, Ben, Simon and other contributors, had the opportunity to make it better.

The fundamental change is that the preference page is no longer about crafting a target platform. It's about choosing the target you need. There are many new features available and there is a proper model (provisional api as well) so interacting with targets programmatically is much easier.

This was the first time I have written a significant UI component in Eclipse. It has been quite the learning experience and I have even more respect for the platform UI folks and those involved with the p2 UI (which has developed into an excellent experience in 3.5). I received a lot of feedback along the way and have made every effort to develop a UI that respects legacy functionality, simplifies the story while supporting power users, and adds useful eye candy without button overload.

In the future expect even more information to come out about how to work with target platforms, talk about some new ideas we are considering, and posts about some cool features you may not notice at first glance (like p2 provisioned targets). In the meantime, try out M7 and let us know what you think!

API Tooling From The Commandline

2009-04-01T21:27:00.010-05:00

API tools has a very nice set of tools for analyzing API, creating .api_description files and scanning for API / internal use to mention but a few tasks. Using these tools currently requires you to make the apitooling-ant jar file available in an Eclipse environment or have them as part of a build process.

We though it would be nice to be able to run the tools from the command line as well. With that in mind we have provided a generalized Ant build file that can be used to do just that. The build file in question is available from CVS in the org.eclipse.pde.api.tools project in the scripts folder. Also available in the scripts folder is a properties which is needed to map the task names to the task classes that provide them.

The build file is fairly simple and has a plethora of comments to help you out. It performs 3 main tasks:
1. it builds the Ant classpath based on an Eclipse install
2. it extracts the apitooling-ant.jar from the API tools project jar
3. it runs whichever task you specifiy in the 'run' target

Here is a sample use of the build file for running the API use scans from the command line:


<project name="apiusetask" basedir="." default="run">
    <property name="scope" value="/eclipse/eclipse_3.4.2/">
    <property name="baseline" value="/eclipse/eclipse.tar.gz">
    <property name="xml.report.loc" value="/eclipse/apiuse-commandline/xml">
    <property name="html.report.loc" value="/eclipse/apiuse-commandline/html">
    <property name="exclude.list.loc" value="/eclipse/exclude.txt">
    <property name="eclipse.install.dir" value="/eclipse/eclipse/plugins">
    <property name="eclipse.lib.dir" value="/eclipse/lib">
    <property name="apiuse.task.props" value="/eclipse/lib/apiuse_tasks.properties">
   
    <target name="init" depends="extract-apitoolingjar">
        <taskdef file="${apiuse.task.props}">
            <classpath>
                <fileset dir="${eclipse.install.dir}">
                    <include name="*.jar">
                </fileset>
                <fileset dir="${eclipse.lib.dir}">
                    <include name="*.jar">
                </fileset>
            </classpath>
        </taskdef>
    </target>
    <target name="extract-apitoolingjar">
        <unjar overwrite="true" dest="${eclipse.lib.dir}">
            <fileset dir="${eclipse.install.dir}">
                <include name="org.eclipse.pde.api.tools_*.jar">
            </fileset>
            <patternset>
                <include name="**/*.jar">
            </patternset>
        </unjar>
        <move file="${eclipse.lib.dir}/lib/apitooling-ant.jar"
                     overwrite="true"     
                     todir="${eclipse.lib.dir}"/>
        <delete dir="${eclipse.lib.dir}/lib/" includeemptydirs="true">
    </target>
    <target name="run" depends="init">
        <apiuse
            baseline="${baseline}"
            scope="${scope}"
            report="${xml.report.loc}"
            excludelist="${exclude.list.loc}"
            considerinternal="true"
            considerapi="true"
            includenonapiprojects="true"
            debug="true"
        />
        <apiuse_reportconversion
            xmlfiles="${xml.report.loc}"
            htmlfiles="${html.report.loc}"
            debug="true"
        />
    </target>
</project>

To actually run the given build file you must have Ant available on the command line (obviously) and then run the following:


  root%>ant -buildfile <build file name>

API Use Scanning Now Has A Face

2009-03-09T09:48:00.003-05:00

With the API use scanning tooling out the door in Ant task form, I thought it was time to put a face on the feature. I know, I know, why would you need UI for the tools when they are already in Ant task form? Because not everyone is 100% Ant-savvy (myself included) and most users like the tactile feedback of clicking a mouse.

The UI for the scanning feature is not in the official build yet, but fret not, we have provided it on our update site.

To access the UI simply open the search dialog. There are plans in the works to expand the capabilities of the UI to not only scan baselines but to handle API elements in general, for now though you can only scan baselines. Happy scanning.

Eclipse Bespin on Slashdot

2009-02-19T13:45:00.004-06:00

So it appears that the Eclipse-based Bespin server created by Boris Bokowski and Simon Kaegi has made it to Slashdot. The comments there reflect my feelings on the whole 'IDEs in the Cloud' concept. It's definitely new and interesting, but how will it be useful to me?

Looking forward to see how this develops in e4.

Debugger Breadcrumb

2009-02-03T14:16:00.003-06:00

In 3.5M5 Eclipse Platform introduces a Breadcrum b feature in the Debug view. Since it's a platform feature it is automatically available with JDT, CDT, or any commercial debugger built on the Eclipse framework. To see the breadcrumb, simply resize the Debug view to make it really short (about one line of text), and the view will automatically switch.

We hope that this feature will make it easier for users to stay in their regular development perspective for majority of their debugging tasks. For example here's a screen shot of the C/C++ perspective with the Debug view breadcrumb above the editor.

If you'd like to try debugging outside of the Debug perspective, there are two things you need to do:

Disable the automatic switching of perspective when debugging happens. Go to Window->Preferences->Run/Debug->Perspectives and select Never for both of the options that start with Open associated perspective...
Enable view management in your development perspective. Go to Window->Preferences->Run/Debug->View Management and select the check-box for your perspective. This will cause Variables, Breakpoints, and other debugger views to automatically appear and disappear when you need them.

Keep in mind that this is a brand new feature and really a whole new work-flow. We already have a growing list of issues to fix, but if you find something new or have ideas for improvements, let us know.

Debug Unit Tests

2008-12-18T11:12:00.002-06:00

There was a recent blog post asking whether the debug framework had any unit tests and if so, where we were hiding them. Yes we do have a test suite to help protect against regressions and we hide it in the org.eclipse.jdt.debug.tests plug-in.

The majority of the tests require some implementation of the debug framework to run. We are responsible for the JDT Debugger, which is part of the SDK and implements the majority of the standard debug model. So the tests were designed to use JDT.

Until Dave brought the idea up, I had never thought of anyone using unit tests to help implement their own debugger. The current tests certainly are not set up for this style of development. I think it would be really cool to have a generic testing harness that checks the behaviour of the framework. Users could have the test harness run against their implementations of the debug interfaces/extensions. Perhaps Bug 259145 could evolve into something like that.

Delivering Feature Patches - Part II

2008-12-04T15:12:00.011-06:00

This post will go over the basics of creating a Feature Patch, the most robust option when wanting to deliver some code changes, as discussed in my previous post.

First we must grab the bundles we are changing and edit the code. For this example I grabbed the org.eclipse.debug.ui bundle from CVS and applied the latest patch for the new Debug Breadcrumbs feature Pawel is working on.

You must also set up your target platform (Window > Preferences > PDE > Target Platform) to be what your intended client is using. Your target platform will determine what feature version you are going to patch. Therefore, to create a patch against 3.4.1, make sure to set your target platform to a 3.4.1 install. In this example I am using my default target platform (the latest I build).

Note that at this point, we could use PDE to launch a runtime workbench and test out the changes immediately.

Now to create the feature patch, use File > New > PDE > Feature Patch. This brings up a wizard with multiple dialogs to fill in.

You will have to choose a project name which is the name of the project that will be created in your workspace. Then you must choose a patch ID and name, which will be what your user sees when they try and install the patch. Finally, you must choose the feature which you are patching. Hitting the browse button will allow you to select one of the features from your target platform, and the name and version will be filled in for you.

Hitting finish will bring up the feaure patch editor where you can edit many more things. For the simple case, we are going to move directly to the Plug-ins tab of the editor. Here, we will specify what new bundles the feature will have. Hit the Add... button and select your workspace bundle. You don't have to specify a version for the bundle because by default we will set the proper versions when we export.

The next step is to export the patch. PDE provides a convenient button in the top right section of the editor which will open the export dialog. Choose a directory where you want to export (you can move this folder to a website later to make it available remotely). You can also export to a jar file.

On this wizard it is also very important to go to the options tab and turn on the "package as individual jar archives" and "generate metadata" options. These options are required for p2 to be able to understand and install the patch.

Hit the finish button, wait for the operation to complete and we're done!

To install the patch, we go to Help > Install New Software... Hit the Add Site button and select the directory we exported to (or the remote location, or the jar file). The dialog should now show our patch, check it and hit next to begin the install. You will have to step through a few pages to accept the license agreement.

After the install completes, we are prompted to restart eclipse (highly recommended). When Eclipse returns, we have a brand new feature to play around with.

So there you go, the basics of creating a feature patch!

Optional: Instead of exporting the patch directly, you can also use an update site project with a site.xml to deliver the patch. Simply open an existing site.xml or create a new site project (File > New... > PDE > Update Site Project), hit the add button, select your feature patch project, and build the site. Using a update site project will generate an html page as well as allow the pre-p2 update manager to access the site.

Delivering Feature Patches

2008-12-04T10:50:00.005-06:00

One of the debug committers, Pawel Piech, has been working on creating a debug context breadcrumb. A cool feature that we are all looking forward too. The current patch applies nicely to the debug ui project, but there is a need to try out the feature in your main Eclipse environment. Self-hosting isn't practical for everyone. There are a couple of ways of doing this in 3.5:

1) Hack them in :) Export the bundles, put them in your install directory, rename them to have the same name and version as the previously installed bundles and start with -clean. This will trick p2 into loading the new code and treating it the same as the previous bundles. This is not a great choice as you are working behind p2's back so if there are any problems, you are on your own.

2) Use the new PDE one step export and install feature. Simply go to File > Export... > PDE > Deployable Plug-ins and Fragments. Then in the wizard, choose the last radio button "Install into running application". This will build your workspace bundles and use p2 to install them into your host application. Assuming all goes well, you'll have your code up and running and you can uninstall the changes using p2's UI (Help > Installation Information).

3) Create a feature patch. While option 2 is the fastest for developers, feature patches allow you to provide the changes via an update site. Users will be able to install without ever checking out any code from CVS. My next blog post will explain the basics of creating a feature patch.

The Debug Team Family Grows

2008-09-24T11:18:00.002-05:00

As of 5:05 this morning, the Debug Team's family grew by one.

Congratulations Mike and Jen on your new baby boy!

Sean Robert Rennie
8.5 pounds, 21 inches

Remember, hyperlink debugging rocks

2008-07-10T12:21:00.004-05:00

While the feature has been around since 3.3, I still consider hyperlink debugging one of the most awesome features of the JDT debugger.

Hyperlink debugging lets you very quickly step into a selected method. Previously, to step into a method you would have to use step over to the line you wanted then step into, or click on the method you wanted and hit step into selection. With hyperlink debugging you simply hit ctrl (or ctrl-alt, I'll explain in a moment), and click where you want to go.

Starting with next week's integration build, the hyperlink debug feature will use ctrl as it's activator (previous versions used ctrl-alt). This change was made because we were the only hyperlink action to have an activator other than ctrl. If there are multiple hyperlink actions available, a handy popup will let you choose which to use.

For those who want to keep the old way of doing things, you can change the setting back to ctrl-alt on the General > Appearence > Editors > Text Editors >Hyperlinking Preference Page. Because I am often debugging a target platform, I often need quick access to both open type and step into selection hyperlinks, so I have switched my preference. If you think that ctrl-alt should be the default, leave a comment here.

Funny Error Dialogs

2008-04-16T15:20:00.003-05:00

I was working today when this gem showed up:

While wondering how much money the person that created this dialog got for using the word 'update' so many times, I clicked 'ok' and got this gem:

Its always funny to see posts about weird / bad dialogs (and messages) so I thought I would share these...

Another Succesful Tutorial

2008-03-17T18:05:00.005-05:00

I've only been in Santa Clara for 24 hours or so, but I've already done so much and had a ton of fun.

First off, I had some time to bask in the sun. Compare...

The view from my balcony at home (at least there isn't much snow, unlike Ottawa)

The view from my hotel room in Santa Clara (oooh palm trees)

Second, I've met a ton of people who I interact with all the time on bug reports, but had never seen in person. Hopefully I left a good impression. Had a lot of fun at the blogger party as well.

Finally, I helped present the two debug tutorials this morning and everything went perfectly. We covered a lot of material, and got some excellent questions. If you are building a debugger using our framework, make sure to let us know about it! We had several people come up and tell us how much they liked our presentation and how great their products are developing because of the debug framework, but it would be great to see them in action.

Tomorrow brings many more possibilities, with many talks, exciting BoFs, and some exercise.

Curtis

Api Tools is Official

2008-02-06T13:52:00.000-06:00

With much joy, I am happy to say that the Api Tools incubator project is now part of the SDK proper. We (Darin, Olivier and myself) have been working very hard to get it up and running (and useful).

The project has come a long way since my last post....

We now have:
1. an incremental builder
2. problem markers for api usage problems / api breaking changes

3. filters for api problem kinds

4. quick-fixes for a variety of api problem kinds

5. a wizard to set up api tooling on plugin projects

6. preference / property pages to configure options for the tooling

7. version management

8. @since tag management

Stay tuned for more updates...

Creating help just got a little bit easier

2008-01-21T16:09:00.000-06:00

Are you looking forward to the 3.4 doc pass? No? Really now, where is your user assistance spirit?

In 3.4 PDE is hoping to improve your documenting days, specifically by making it easier to create, edit and review context sensitive help. The first step was to create a fancy new editor...

The editor allows you to quickly create and edit new new contexts, topics and commands. But the addition of dragging and dropping, cutting and pasting, opening linked files in various views, and more, is what makes this editor so much better then trudging through the xml. The editor should be the default editor for context help xml starting with today's I build.

There's more to come as well. During 3.4 PDE will hopefully be adding more features to help connect the context ids in your code with those in the xml.

A big thanks goes out to Chris and the PDE team, who managed to review and commit my 5000+ line patch in record time.

API Tooling is a work in progress

2007-11-22T09:13:00.001-06:00

Lately I have had the chance to work on a new project a little outside the scope of debuggers: API tooling support for the platform. Ultimately the goal of this incubator project is to provide tools for 'working' with APIs. Working in this context is loosely defined as:

1. Manging API usage across builds/products
2. Creating API profiles to compare against
3. Tools to compare APIs
4. Tools to manage API breakage detection/repair
...

Alot more information can be found on the wiki for the project (here).

One of the features currently available in the project is the ability to manage API profiles. API profiles are considered to be a description of the API of a component (which can be a project, plugin, bundle, etc). These profiles can be used to compare current source to, or another component.

The following screenshot is the 'API Profiles' preference page used manage API profiles (hence its name :) )

Another feature is the ability to use Javadoc source tags to define API restrictions. The tags are provided as completion proposals for classes, interfaces, methods and fields. For example you could add a @noimplement tag to an API interface that clients are intended to use but not implement.

The following screen cap is a shot of a Java editor showing a variety of source tags.

These are of course previews of current ongoing work, so it could change at any time :)

One year of contributing

2007-10-30T09:21:00.000-05:00

It has been exactly one year since I started working at IBM and one year since I started contributing to Eclipse.

To celebrate, I am spending the whole day testing!

... I suppose I could have tried to find something more fun to do. Maybe next week on my birthday (which happens to be Eclipse's birthday as well), I'll imbibe some kind of frosty beverage.

Searching Now Includes Launch Configurations

2007-10-22T08:40:00.000-05:00

I love the community of Eclipse, and how some people, other than us committers take time to re-examine old bugs that they are interested in. Most recently bug 57515 was re-examined by the community, which resulted in the patch being committed, and the debug team having a new feature to brag about :).

Without further ado, this post is about searching, search participants and the new-fangled feature that returns launch configurations as search matches (when looking for Java types). To be more explicit, only launch configurations that have a main type attribue to search against will be found as possible matches.

Ok so really that last paragraoh was all there was to say about searching, etc. But you can check out a snazy screenshot of the eclipse search view showing a Java launch configuration match.

Thanks again Peter for the patch for a cool feature.

Import/Export Launch Configurations

2007-10-04T09:18:00.000-05:00

This week I thought to myself, "lets fix a really old bug that has been marked LATER". So I went off looking for a bug or enhancement to try and find a good one. The best I could come with was importing and exporting launch configurations, bug 12898 (to and from the local file system). Rest assured there were a lot of cool bugs, but I also had to find one that would not take a long time to fix...

A good part of the idea behind this one was that not everyone uses CVS (or a variant) to share code (making shared configs almost useless). Most people also do not know where launch configuration files are stored in their workspace. With that in mind you can now fire up the export wizard, choose launch configurations, select the ones you want and the location to save them and PRESTO (not the pasta sauce) you get an instant copy of the selected configurations in that new location.

The export wizard

The configuration export wizard

Now lets say you have you have a bunch of launch configurations in a folder that you would like in your workspace, you can use the import wizard to make this happen. The import wizard uses the standard 'import resources' widgetry, so there should be nothing new in this wizard page (provided you have imported something from your file system before).

The import wizard

The configuration import wizard

You're welcome.

It never ceases to amaze me...

2007-09-19T15:06:00.000-05:00

In the relatively small amount of time I have been contributing to Eclipse, I have grown to expect great things from the platform and the community. Yet, on a regular basis (often coinciding with updated new and noteworthy pages), I find myself thinking "Cool, I didn't know you could do that.". I am also constantly astounded by the enthusiasm, support and knowledge of Eclipse committers.

So what has caught my attention this week? Plug-in Spy is the tool I have been searching for since I started working on Eclipse. Now I can instantly determine the class for an open dialog, link to the source and edit it. Another useful feature that I found was the zip file comparator. I'm not sure how long it has been around, but I discovered that you can see the outgoing changes to a zip file in a nice directory structure with changes to individual files shown. I was also reminded of how powerful context launching is when it stopped working.

I stepped into PDE land for a couple of days to work on an import quick fix feature. The enthusiasm of the PDE team is unparalleled. Brian Bauman, along with other committers, made working on it both enjoyable and straightforward. Keep an eye on PDE's M2 new and noteworthy.

It was great to see a community member, Joe Pluta, step forward to help out with our M2 test-pass (there were only two committers available to test this week). I updated our Get Involved web page, and hope that others would consider helping out the debug team (or any other Eclipse team). There are many ways to get involved, including testing for defects, triaging bugs and contributing fixes.

Don't forget that Sept. 28th is Bug Day!

Sharing Makes the World Go 'Round

2007-09-12T08:08:00.000-05:00

New API released in JDT Debug project: our Java launch shortcuts (finally).

Gone are the days of having to copy and paste all of our code so that you too can have a base Java launch shortcut with a couple of different 'tweaks'. Now every contributor has the use and extensibility of all of our Java shortcuts (and their parent abstract class) without getting those annoying 'discouraged access' warnings.

There are three classes in total, made available in the package org.eclipse.jdt.debug.launchConfigurations:

1. JavaLaunchShortcut (the abstract parent class)
2. JavaAppletLaunchShortcut (our concrete implementation for launching applets)
3. JavaApplicationLaunchShortcut (our concrete implementation for launching Java applications)

((Debug + Context Launching) >> 32)^2

2007-09-05T11:05:00.000-05:00

New to 3.4 is context launching 2.0.

With this new addition people who want to take part in context launching but do not care about IResource's can participate as well. Gone are the days of context launching only working for 'things' that have an IResource adapter. Now anyone, using nothing more than the new API for a launch shortcut, can have a say what should be launched, or what resource should be launched (if any).

The new API in question comes from ILaunchShortcut2 (which surprisingly is an extension to ILaunchShortcut), and provides 4 new methods:

1. getLaunchableResource(IEditorPart)
2. getLaunchableResource(ISelection)
3. getLaunchConfigurations(IEditorPart)
4. getLaunchConfigurations(ISelection)

With these methods contributors can now tell context launching either which resource it should be launching, or what launch configurations it should be launching.

Out of Lockdown V2.0

2007-07-17T09:35:00.000-05:00

As Curtis put it: it is nice to be out of the 3.3 lockdown. It means that we can start writing some cool code and adding in some cool new features. Curtis already told you all about the cool new dragging and dropping. I will tell you about non-resource based context launching.

You might remember back in 3.3M6 when we added in the new feature for context sensitive launching, heck you might even be using the new feature. For all the good that it brought to the world, it did have a severe drawback; it did not work with project artifacts that were not resource based (had or could get a handle on an IResource).

What we want to do now (in the start of 3.4) is extend context launching to allow contributors the ability to tell us how to launch something. That way if we don't know how to launch foo.xxp you can provide a context launching participant to tell us how you would like it launched.

We are hoping that this will bring together the best of all worlds of launching and make it even easier for novice to expert users to make use of launching/development in Eclipse.

Escape from 3.3 Lockdown

2007-07-12T12:46:00.000-05:00

It's so nice to be out of the 3.3 lockdown. We can finally put some new features in (plus there was time for a week long vacation in Rushing River). In the two weeks spent working on 3.4, the Debug team has already added many new fixes and features. One of these new features is dragging and dropping for the variables and expressions views.

To create a new watch expression for a variable in the variables view, you simply select a variable and drag it to the expressions view. You can even select multiple variables to create expressions for them all.

To create a new watch expression you can also drag text from the editor or anywhere that supports text dragging. Drag selected text onto the expressions view to create a new watch expression with the dragged text as its code snippet.

When dragging to the expressions view you can insert to a specific place in the view, or just add it to the end. You can also drag existing expressions to reorder them in the view.

During 3.4 the debug team is looking at other ways to use drag and drop to improve the user experience. If you have any ideas, leave a comment or file an enhancement request.

Darin Wright, Champion Among Men

2007-06-21T10:47:00.000-05:00

Today I would like to make a post telling everyone that our manager, Darin Wright is indeed a champion among men (not just to get a promotion).

On the ride to work today, as Darin rides his bike to work every day, he was hit by a truck. Luckily he was not harmed in any way, and yes the driver was talking on his cell phone and not paying attention.

But this is not what makes him the champ.

The fact that he walked what was left of his bike home, fixed it, and then rode it to work (again), and then once he got here was still happy to be at work, is what makes him the champ.

Axesome.

Facebook is the new Eclipse Hangout

2007-06-20T11:19:00.000-05:00

For all you Eclipse Committers (and Committer wannabes) who hang out on Facebook at least once in a blue moon, Mike and myself have started a new group for you. The group is called Eclipse Committers and is of the type: Internet & Technology - Software.

So join up, say hi, and let everyone see all the embarassing information you leave on your Facebook profile.

iClipse

2007-06-19T09:14:00.000-05:00

For all those Mac users out there, Eclipse 3.3 comes with an important fix. You can now run and debug applications on more than the OS default VM. We discovered that an environment variable on the Mac (JAVA_JVM_VERSION) controls which VM gets launched. Eclipse now modifies this environment variable for each new process (VM) that gets launched, to match the user selected JRE.

Cleaning the bug buckets

2007-06-18T15:30:00.000-05:00

Over the last few weeks the debug team has been going through the dreaded and controversial "Resolved - Later" bugs and feature requests. I wasn't able to come up with the right Bugzilla query to get exact statistics, but I know we had over 800 Resolved-Later bugs last month, and now we're sitting at 715. Not bad - that's over a 12% reduction! Some bugs had been fixed along the way (always a nice surprise), some had become irrelevant, some were re-opened to be addressed, and some were even re-opened with fresh patches to be applied soon.

Just another seven months and we'll have had a chance to look at each one :-) Be patient.

One Europa Experience

2007-06-15T12:20:00.000-05:00

I swear I'm not just doing this for the free shirt. With only 2 weeks to go until it is released, I figured it was time for me to get a taste of Europa.

The coolest thing about Europa is that it should make it easy to install a large number of tools. Using Europa, you spend your time using the tools, not installing them.

Does Europa do a good job at this? I'm not entirely sure, my experience was far from perfect, but I can't say I regret it.

The good:

- The ability to see such a wide variety of projects in the update manager, choose the ones I wanted and have the manager select all the required plugins is great. I was unable to resolve dependency issues for the Buckminster project, but I'll just assume that it will be fixed in the next couple of weeks.

- Once I had Europa up and running, I found a lot of axesome tools, many of which use the platform and/or the JDT debugger framework. I was impressed by the functionality available, so a pat on the back to all the teams out there creating these open source tools.

The not so good:

- The welcome page seemed so empty and not helpful considering how many tools I had installed.

- The preferences dialog is scary. It is a strong encouragement to use the default settings. Expect to spend a long time going through it if you like having everything configured the way you like it. Oh and don't forget to export your settings when you are done.

- Before I could even close the welcome page, Mylar was helpful enough to open a dialog, preventing me from doing anything until I set some preferences. What is so important about the Mylar options that they need a dialog on startup vs a preference page. This dialog got even more annoying when I clicked the link at the bottom to watch a video about getting starte with Mylar. The progress bar showed up for a second and that was it. Once I closed the welcome page (after just hitting okay on the dialog with the default settings), I discovered several web browsers open trying to show me a video (which had been moved due to the renaming of the Mylar project).

- After playing around with some of my freshly installed tools, I checked the log. Sure enough, errors galore from multiple projects. Europa is only 2 weeks away. Having dozens of errors in the log is not going to make us look good.

- While I found the update manager to be an effective way to install the tools, Mike may not agree. For starters while using Europa, his chair broke. The handle broke right off. Oh and his Eclipse installation crashed and wouldn't launch again.

Overall, I like Europa and I think it goes a long way to make it easy for users to get the projects they need. Plus, users who use Europa to get a couple of tools they need are likely to try out some of the other projects available. But things really need to be polished in the next couple of weeks.

Whats Up Doc?

2007-06-07T13:10:00.000-05:00

Ok, first off let me say I just couldn't resist on the title, I know it is corney, stupid, etc, but I had to let it out.

Todays post is about how much I love to write doc for our plugins and the number Z.

Writing doc is one of those things that we all hate doing, but we all agree needs to be done. This lack of enthusiasm is probably why it is put off until the very last minute in the release cycle instead of being done during the release cycle. I think deep down inside everyone really likes to write doc, as it takes us away to that magical "working but not really" place where we can spend hours and feel a sense of self worth....or not perhaps.

Let me leave this post on a positive note by saying how much I love to write doc.

Context Launching....Friend Or Foe

2007-05-11T11:25:00.000-05:00

In 3.3M6 some of you might have noticed that launching has changed...just a little bit.

In an on-going effort to make the world of launching in Eclipse just that little bit easier for novice users, we have introduced the concept termed 'context launching'. The premise of context launching is that we do everything in our power to try and run whatever the 'thing' you have selected is; failing that we give you the option to try and run the project it is contained in (if there is one). Furthermore, during the context launching process we abstract the hassle of having to create launch configurations or activate shortcut menus by creating the configurations for you, and presenting 'ways' of launching for users to select (if there is more than one way to launch the 'thing' selected).

Lets stop here for a second so I can tell you that YOU CAN TURN CONTEXT LAUNCHING OFF on the launching preferences page if you don't want to be cool and use the newest coolest launching stuff (but thats fine, I am not in charge of your coolness, I only provide the tools to increase it, a-la your_coolness++).

Ok back to context launching and why you can't do without it.

To provide context launching (so far) we have taken all of the familiar launching artifects, like launch shortcuts, etc, and rolled them all into one, leveraging it such a way that you can simply press the run or debug button (when context launching is on that is) and have a configuration pertaining to what you are doing be launched. Right now context launching is limited to things that have an associated IResource (using adapters), but this will likely be extended in the future to include non-resource based stuff (see see this bug).

The upshot of this is that no matter if you are a plugin, java, etc developer there is no 'new' stuff to learn, all you have to do is press the button (or use the menu shortcut). Even if you spend days creating the best launch configuration in the world it will be used in context launching, as we also make use of your launch history and favorites to help make decisions about what to launch and when. The downside is that it does not cover 100% of the edge cases in launching (
see this bug).

There is more specific information about context launching and how we implemented it (see this document) if you are interested.

So for now, we'll leave it at that and I hope everyone enjoys context launching and provides feedback if they don't, but like I mentioned I cannot be responsible for any depreciation in your coolness if you don't like it.

This feature has officially been labelled Axesome.

Export More Stuff For Everyone

2007-03-30T15:08:00.000-05:00

Are you one of those people that just has to have everything just so? even to the point of having your collection type variables show exactly how you want them? Well if you are you no longer have to fear losing all of those custom logical structures you speant so many hours making.

You can now export and import Java logical structure preferences separate from other workspace preferences. Java logical structures are defined on the Java > Debug > Logical Structures preference page.

This is a cool feature...but not quite axesome.

Hyperlink Debugging

2007-03-30T11:34:00.000-05:00

I know I have been silent for qute some time, so I figured it was time to come back to the blogosphere and drop some more knowledge. This time (nothing like that breakpoints post) we have an axesome new feature which is proving to be far more handy than any of us could have really imagined (except Darin of course because he knows everything); Hyperlink Debugging.

The idea behind hyperlink debugging follows that useful feature that pretty much everyone already knows about: hyperlink open declaration (Ctrl+Click in editors open declarations). Except in our case you can do lightning fast step-into operations with but the press of Ctrl+Alt and a click of the mouse....not impressed yet? check out the example.

Lets say you wanted to step into the createComposite method shown below:

SWTFactory.createComposite(getParent(), mainComp.getFont(), getStyle(), getFill());

The old way, you would have to step into and out of all of the method calls in the createComposite method prior to stepping into the one you wanted. You could of course use the old passe method of step into selection...but just imaging being able to step into creatComposite with a single click...no more selecting code, no more repetitious step into/out of code.

You can even select what keys to use as modifiers (thanks to the jdt UI guys of course).

I know what you are thinking....Axesome.

Custom Detail Pane Widgets

2007-02-15T09:55:00.000-06:00

First off, let me introduce myself to all you avid Debug Team Blog readers. My name is Curtis Windatt and I am the newest member of the debug team. I have been working with Darin and Mike at IBM in Winnipeg for almost four months now and I am looking forward to receiving commit rights to the debug projects in the not so far off future.

The first major feature I worked on is adding support for custom detail pane widgets (Bug 75852). This feature allows plugins to contribute new detail panes. The “detail pane” is the area in the variable, expressions and registers view that displays information about the currently selected variable. Up until now, the detail pane could only display text.

Now it can display colours! This custom pane changes background colours depending if the selected element is public/private/etc:

Of course, it can display much more than that. A custom detail pane is defined by implementing org.eclipse.debug.ui.IDetailPane. The pane can contribute any SWT Control, including Composites that contain multiple controls, to the detail pane. When the user makes a selection the custom pane is passed the selection so it can display the information however it wants. The user can use the context menu to choose between the different detail panes available for the current selection.

To contribute a custom detail pane you must use the new extension point org.eclipse.debug.ui.detailPaneFactories. At this extension point you specify a class implementing org.eclipse.debug.ui.IDetailPaneFactory. Each contributed factory will be asked what detail panes that factory can produce for a given selection. A factory can offer different combinations of detail panes depending on the selection. For example, a pane might only be available when 2 or more java variables are selected. To reduce plugin loading, plugins can also add enablement expressions to the extension so that the factory is only instantiated if the selection applies.

We are looking forward to seeing what people can do with this new feature. Leave a comment or send us an e-mail if you create one. In the future we will try to make an example plugin and possibly a short tutorial available.

All About Perspective

2007-01-09T08:17:00.000-06:00

In line with the changes to the launching framework (retargetting launch delegates, etc), we thought it would be a good idea if we could also fit the 'new way' of launching into the existing perspective switching way of things.

We felt that with such fine control (now) over how and what does the launching, it would be a nice addition to extend that notion to perspective settings. For example, consider you have two profilers that both launch a Java application with profile options. Traditionally this would have led to perspective switching based on which-ever launch delegate was chosen in the end, leaving the user no control over what would be switched to based on what did the launching.

Now however, the user can select down to the launch delegate level to specify launch perspective settings. Changes to these setting can be applied on the Perspective preference page as before, with the only notable change being to the launchers tree (see screen shot).

This new page design also allows multiple perspectives to be set at one time, i.e. you can multi-select items in the tree and set perspectives for common modes to all delegates/types in the selection. You can also over-write common perspective settings for launch delegates of a particular type by changing the perspective settings of that type.

This new hotness is available in builds >= Jan 9 2006

Mixed-up Launching

2006-12-06T10:19:00.000-06:00

I guess since it has been quite a while and we have made a pile more changes, it would be a good idea to maybe discuss some of it on "the blog".

The most notible additon to the debug platform as of late is mixed mode launching. With this new launching notion, we can perform things such as debugging and profiling at the same time....say what? The functionality to do so is an implementation delail that is not provided in the platform, but surely some on-the-ball client of the debug platform will provide it :) -- never-the-less the ability to have mixed mode launching still exists.....really it does....you can believe me....have I lied to you before?

Along with mixed-mode launching we have vastly improved contributing to launching in Eclipse:

To extend an existing tab group is now as simple as contributing your own tab...gone are the days of recreating the entire tab group to add one or more of your own tabs. You can even specify the location of your tab...oh my!
Name and description fields have been added to the schemas for launch delegates
Launch delegates (the code that actually launches stuff) can be retargetted dynamically during the launching process
Duplicate launch delegate detection is now in place, with resolution mechanisms and a framework to set preferred delegates for both the workspace AND for individual launch configurations

So basicallly we have made a tonne of changes that 99% of normal users will never see, because it all appears to work the same on top. Making improvements noone ever sees or cares about rules.

There is some more information and a test plugin available from the debug team webpage
here: http://www.eclipse.org/eclipse/debug/documents.php.

Oh and here is a screenshot showing the launch dialog opened with more that one launcher available and some contributed tabs added after the Main tab:

Terminate Key Binding Requests (please)

2006-09-25T10:24:00.000-05:00

The platform is running low on available key-bindings. So, we've decided to add one final key-binding for the debugger's terminate action. The action has been mapped to "CTRL-F2". If you can figure out how to use the key binding preference page, feel free to change it.

We've also fixed a small bug in the Debug view context menu. Key-bindings are once again displayed for the standard step commands in the context menu (when you are debugging). During 3.2, the actions were all changed from view contributions to being contributed by actual code. When we did this, we forgot to assign action definition id's in the code. Woops. Fixed now.

Painfully Fast (Now)

2006-09-19T15:50:00.000-05:00

Today the debug team revels in its own greatness...Ok we didn't actually fix anything, but we did find out that a bug that was a critical stop ship for us was not at all our fault AND someone had already fixed it (I love those ones).

The bug in question is https://bugs.eclipse.org/bugs/show_bug.cgi?id=153458, and long story short, has to do with the apparent 'extreme slow down' of the eclipse debuger. It turns out (as the previous comment dictates) that it was not our fault; it was really a combination of factors...but mainly the new conjestion algorithm in the newer Linux kernels (> 2.6.14). Luckily though the kernel champions jumped on it and bullied Sun into fixing the way jvms communicate over TCP/IP.

To summarize:
If you have a newer Linux kernel (> 2.6.14) and you are NOT using jdk 1.5.08 or jdk 1.6 r79 you are boned, and doomed to have a matrix-neo-style debugging experience.

A Whole Lotta' Instances

2006-08-29T16:25:00.000-05:00

A first draft of another one of the new Java SE 1.6 features is out and ready to be played with. Much like the other feature (All References), All Instances works in pretty much the same way. You can right-click on a variable and select the All Instances... menu item, and before you know it WHAM, you see a popup showing you all of the instances of the selected object in the current VM. Isn't that dandy.

Much like it's companion All References, you of course need a Java SE 1.6 VM to use this feature, and you must be debugging at the time (i.e. have variables in the variables view). There are plans in the mix to expand its availabilty to the Outline View and to a context menu in the java editor....we shall see.

The first image below shows the location of the new action, and in this case we have selected a string, which will result in a popup showing all of the instances of type String in the current VM.

This next image shows the resulting popup (yes it is the inspect popup) telling us that there are 769 instances of String in the current VM. Allow me to say again, dandy.

To try out this...dare I say again...dandy new feature, you will have to wait until the next build or grab the source from HEAD.

Browse All References (J2SE 6 only)

2006-08-09T12:55:00.000-05:00

If you're running your Java application with a J2SE 6 virtual machine, you can browse all references to an object in the variables view. Select any object in the variables view, and choose All References from the context menu. A pop-up displays all objects referring to the selected object. You can expand each node in the tree to follow references to each object. You can inspect any object in the reference tree by selecting it and pressing Ctrl+Shift+I. This opens an inspect pop-up displaying the object's fields.

This feature is available in the latest integration build and forthcoming 3.3M1 build. It's our first cut of the feature, so feedback and comments are welcome.

Let the pain slip away

2006-08-02T16:31:00.000-05:00

Seeing as how I seem to be in such a blog-tastic mood....the debug team has provided another fix to try and lower the overall frustration of level of at least a few people.

Have you ever been nailed by the "java.lang.UnsupportedClassVersionError: foo (Unsupported major.minor version 49.0)" error? If you have this applies to you.

In an effort to make life a little less painful, we now do compliance checking in the JRE preference page and in the launch configuration dialog. So if you change your default JRE to be lower than the compiler compliance level you get a nice warning and a link back to the compiler page to change the compliance level.

Alternatively in the launch configuration dialog compliance issues are treated as errors (since you can't launch anyway) and you see the nice angry error message.

Just like the previous breakpoint axesomeness, you will have to wait until tomorrows build to try it out...

Breakpoints are Axesome

2006-08-02T12:10:00.000-05:00

Everyone loves breakpoints. Why else would you debug if you did not want to use breakpoints?
That being said, this last week we refactored alot of our breakpoints code to make it better all around and to add some new features.

For example:

If you use the shortcut Ctrl+Shift+B, you will get the correct kind of breakpoint (instead of just a line breakpoint)
Added new Run menu item "Toggle Breakpoint" which is now bound to the Ctrl+Shift+B shortcut (which also retargets the command to create the proper breakpoint, see point 1 above)
You can toggle Class Load breakpoints like other breakpoints (using the shortcut, double clicking on the ruler, or using the Run->Toggle Breakpoint menu)
That slight flicker in the breakpoints view when you create method breakpoints or watchpoints is gone.
Improved menu population/enablement for toggle breakpoints actions in the Run menu, Outline View and the Variables View.

Here is a screen shot of the new Run menu item.

All this breakpoints goodness will be available after tomorrows build...

What can your VM do for you?

2006-06-26T14:01:00.000-05:00

This week is busy like all the rest. Following the trend of adding in new features all the time, here is another interesting one for you. You can now check the capabilities of the VM used to launch a program by inspecting the properties of any Java debug element in the Debug View (to do so right-click on the element in the view and click the 'Properties...' menu item).

The properties dialog is the same one as before, which contains the process information, but now also the VM capabilities (as long as the target is not terminated or disconnected). You can even expand or collapse items on the page depending on what you want to see, and the page will remember that setting for the next time you open the dialog to view capabilities.

So if you were always wondering "hmm can my VM do that?" now you can check for yourself. To use this latest feature you will need to wait for this weeks I-build, or for tomorrows N-build.

Can I launch my launch from the launch shortcut?

2006-06-26T13:51:00.000-05:00

Last week was very busy for the Debug team. Along with the addition of the new formatting feature for Stack Trace Console, we also added a new feature which allows users to directly run a shared launch configuration using the context Run As... menu and selecting the launch itself.

No more fussing with the launch configuration dialog to run shared configurations (unless you like needless work) YAY.

You will have to wait until this weeks I-build, or grab an N-build from any time after last thursday to check it out.

Kevin's formatting magic

2006-06-21T15:49:00.000-05:00

We added a new feature to the Java Stack Trace Console this week. It will now format your stack traces for you automatically when ever you paste them into the console if you desire. You'll have to download this weeks Integration build to try it out.