Project Structure

The Mylyn project is structured into the following update sites and distributions. Mylyn extensions are split into two different categories. Connectors extend Mylyn to different task management systems. Bridges focus the artifacts that you work with when you activate a task.

Getting Started

The Mylyn project places a very high value on community contributions. This document is intended to help those interested contribute to Mylyn. It communicates our conventions and discusses ways to get your contributions prioritized.

Individual Contributors

A significant portion of Mylyn contributions have been made by individuals wanting to make the tool or framework work better for them. There are several ways that individuals can get involved with the project:

Mentoring: if you are an experienced user, you can support newcommers by providing feedback using the community channels

Casual contribution: we have a large number of very valuable casual contributors who provide patches for their pet bugs, or enhancements that either they would find valuable or that they want to share with others. If you are interested but don't know where to start look first through the short list of bugday bugs, and then through the longer helpwanted list.

helpwanted bugs: a longer list of all bugs targeted at community contributions

Working towards commit rights: The Eclipse and Mylyn development processes make it easy to make regular contributions without requiring commit rights, but frequent contributors may be interested in earning commit rights. Commit rights come with a significant overhead of user support as well as the need to follow the project's priorities for contributions. They require you to participate in the planning and of the project, and allow you influence the direction of the tool and framework. If you are interested in becoming a committer we recommend letting one of the existing committers know so that they can mentor you and help build a trust relationship. It can also help to identify a separable component of the project that you are interested in taking responsibility for, since Mylyn commit rights are assigned per-component.

Integrators and Vendors

Those building both closed and open source tools on top of Mylyn may be interested in evolving the Mylyn APIs to ensure that that the framework meets their needs. We welcome such contributions just as we welcome individuals making improvements to the tool, since they help make Mylyn a better framework for all. The Individual Contributor points above apply to integrators and vendors interested in contributing or earning commit rights. In addition, the following tips may be of interest:

List your extension on the Mylyn Extensions page. This will help the Mylyn community become aware of the extension.

If interested in exploring Mylyn integration, consider dialing into the our weekly call and adding an agenda item on the Mylyn Meetings page.

Vendors are welcome, so make yourself known. We recommend using your company name for Bugzilla email addresses. If you have a product built on Mylyn and need a bug fixed, we recommend voting for it with that email address. The Mylyn project prioritizes bugs according to how much overall benefit they will have to users, and as such commercial integrations are an important part of that prioritization. If the bug does not fit with the project's priorities we will encourage you to provide a patch.

Consider making a bug titled "support integration with <your tool>". We use these bugs for discussing integration issues particular to a specific tool or technology and leave them open for ongoing API or UI discussion needs.

Links

Workspace

The recommended way to work with Mylyn sources is by checking them out of CVS. Doing this makes it easy to try the latest changes and work with patches and ensures that you can easily browse the source code and documenation using Eclipse's facilities and avoids compilation problems such as PDE bug 157375.

Setup

Install Eclipse and get it configured for developing Java 5 applications.

If you get an error similar to Access restriction: The type MimeHeader is not accessible due to restriction on required library /usr/lib/jvm/java-6-sun-1.6.0.07/jre/lib/rt.jar either upgrade to Eclipse 3.5M4 or later. Alternatively associate J2SE-1.5 with a version of Java 1.5 (do not use a later version) as described above.

Checkout

The Mylyn CVS repository contains the following branches. Each can be checked via saving the linked .psf file locally, and then using File -> Import -> Team Project Set. Use username "anonymous" and an empty password. If you are only interested in parts of Mylyn, the additional projects can be deleted after the import. After the checkout you should have no errors or warnings from the Mylyn projects.

Note: these project sets specify anonymous pserver access. If that does not work for you see the CVS Howto.

Release Tags: Each release is tagged with R_. For example, Mylyn 2.2.0 for Eclipse 3.4 is tagged as R_2_2_0 and the branched Eclipse 3.3 plug-ins are tagged R_2_2_0_e_3_2.

:pserver:dev.eclipse.org:/cvsroot/tools can be used for manual checkout

Target Environment

Mylyn depends on a number of libraries from other Eclipse projects. The org.eclipse.mylyn.releng project provides target environment definitions that specify all required dependencies. After following the steps under Checkout go to Window > Preferences and open the Target Platform page. Select one of the mylyn target definitions depending on the Eclipse platform you are developing against.

API Baseline

An API baseline for the latest releases is available from the download archive. Follow these instructions to configure the API baseline in your workspace:

Extract a version of Eclipse Classic (SDK) to a directory that matches the version of your current target platform

Extract the Mylyn API baseline zip archive to the eclipse/plugins directory from the extraced SDK

Add the baseline under Windows > Preferences > Plug-in Development > API Baselines pointing to the eclipse/plugins directory from the extracted SDK

Markers

The general policy is that plug-ins should not have any errors or warning markers since these indicate potential problems or API insufficiencies. In practice, we do not have the capacity to address all warnings or the cost outweighs the benefit or warnings result out of intentional design decisions, e.g. usage of deprecated APIs for
maintaining backwards compatibility.

To reduce the number of warnings we have established the following policies for usage of internal packages:

Plug-ins are allowed to use internals within the boundaries of their component (e.g. o.e.m.bugzilla.ui may access internals of o.e.m.bugzilla.core). We have generally allowed that through x-friends relationships in plug-in manifests.

It's generally okay to use provisional APIs. We have made these accessible through classpath filters: Project Properties > Java Build Path > Libraries > Plug-in Dependencies > Access rules. It's common that plug-ins have a rule to make org/eclipse/mylyn/internal/provisional/** accessible.

In cases where platform internals need to be accessed due to a lack of API it's okay to make the specific classes or packages accessible. These cases should be documented on bug 233055.

Test plug-ins are allowed to use all internals.

Additionally, it is recommend to create custom filters in the workspace to hide remaining warnings that will not get addressed in the short time. Filter can be configured through the view menu of the Markers view.

JUnit Tests

Each component has it's own All<Component>Tests suite. If not familiar with running PDE JUnit tests, refer to the Eclipse Documentation.

Add a credentials.properties file to org.eclipse.mylyn.context.tests and put the following into it:

user: <user>
pass: <pass>

For <user> use "tests<at sign>mylyn.eclipse.org". For <pass> use "<project's name lowercase>test". If you have any trouble making this work email mylyn-dev@eclipse.org.

Add the following to the test configuration under Arguments -> VM Arguments: -enableassertions -Xmx384M

Test suites in org.eclipse.mylyn.tests:

AllTests: all automatic tests, should always pass, run as a JUnit Plug-in Test

AllHeadlessStandaloneTests: do not require workbench, can run as JUnit Test, subset of AllTests

You can use the existing workspace that you used Mylyn with previously

You can create a new workspace (e.g. C:/Dev/bootstrap)

Launching with this launch configuration will give you a second workbench with Mylyn. This workbench will be created based on the target platform (the workbench you're launching from) and the plugins in C:/Dev/build-3.3.

Do your development in the runtime workspace (C:/Dev/workspace).

Whenever your changes make it into HEAD that you would like to use, close your runtime workspace (C:/Dev/workspace), update from CVS in the build workspace (C:/Dev/build-3.3), and then re-launch your runtime workspace.

Notes:

The launching workspace will typically consume very little memory.

Working in bootstrap mode means you have the source code checked out at least twice, once to bootstrap Mylyn, and once to actually develop.

You must have two distinct workspaces, you can't bootstrap into the same workspace as you launch from.

It is possible to run in debug mode so that the changes apply to the workspace immediately after synch, but this can cause problems with the running workspace if classes change or go missing. This is because the hot-swap virtual machine can only change method bodies, not class definitions.

Contributors

All contributions to Mylyn need to be made using Mylyn since it links source changes to tasks and contexts, making open development and collaboration easier. Using Mylyn ensures that:

All Bugzilla reports have a corresponding task context, making them easy to reopen or pick up by you and by others.

All commits correspond to a single Bugzilla report, making it easy to navigate from changes to bugs.

Getting Started

Use Bugzilla for all of your communication. This helps committers track the contribution.

Before setting out to contribute to a bug report, post on the bug report describing your intention. This helps committers guide the contribution and avoids problems with patches going stale due to related work being done concurrently.

For contribution ideas see the list of helpwanted bugs to find one that interests you, file a new bug of your own, or email mylyn-dev for ideas.

Tips

Following these steps will help get your patches applied more quickly.

Before implementing the functionality post a brief proposal of the implementation and UI changes/additions and get a committer's feedback. The committer should be either the component owner or your mentor.

After that's applied iterate on the UI proposal if needed and the post the patch to the UI.

Note that the smaller you make patches and the more focused they are on individual and well-tested units of functionality the more quickly they will get applied.

Voting

We use votes in order to track the general interest in a particular bug. Bugs with more votes are more likely to get fixed. However, we also have numerous "[connector]" bugs that are open, but out of the scope of the project. We encourage all in the community to vote for bugs, since it helps contributors prioritize work. If you notice a vote from a committer on a bug, the likely reason is that they would like to see the fix as well, even though the current priorities may mean that it is not planned for the near future (e.g. a UI enhancement while API is being prioritized).

Patches

In order to make your patch get applied as quick as possible, we recommend the following workflow:

Comment on the corresponding bug, asking whether a committer or another contributor has any suggestions for the implementation approach.

After a committer iterates with you on the design, prefix the summary of the bug report with "[patch]", and wait for review.

Note that the review process might involve iterating on the patch, especially if there are UI changes or additions involved.

Creating

Each patch should correspond to a single bug report, and a single patch should be made for each set of changes to be reviewed.

A task context should be attached to each patch to make applying and evolving it easier.

With few exceptions patches should be accompanied by a JUnit test, and in general unit tests are one of the most valuable and long-lived contributions. If you are having trouble writing a test (e.g. trickiness verifying what happens in the UI) comment on the corresponding bug report so that we can point you at similar test cases or consider extending the test harness if needed.

Minimize the amount of changes to existing code to make review easier.

Synchronize often to ensure you have the latest code. Once you start modifying resources, put the Synchronize view in Outgoing mode and press the Change Set button so that the changes are tracked per task.

Before creating a new JUnit test class class check the components test suite for similar test cases (e.g. AllTasklistTests).

Set the formatter by importing org.eclipse.mylyn/mylyn-settings-formatter.xml from the org.eclipse.mylyn project into Window -> Preferences -> Java -> Code Style -> Formatter. Format code using Eclipse's formatter (Ctrl+Shift+F) and ensure that no have been added.

Add an @author tag to each class that you create or make significant modification to, placed below any existing author tags and indicating the bug, e.g.: @author Rob Elves (bug 160315)

Ensure that there is no console output. For logging errors use org.eclipse.mylyn.monitor.core.StatusHandler.

If tempted to copy code from either Mylyn or any other part of Eclipse, please first comment on the bug that you intend to do so. The need to copy code is often indicative of the need for us to provide additional modularity, and creates a maintenance burden for the project. If you do copy code, please put an @see link in the Javadoc for the method or class that has the copied code.

Submitting

Ensure there are no build errors, warnings, and that org.eclipse.mylyn.tests.AllTests passes.

Do not include binary files such as GIF icons in the patch, they need to be attached separately.

Synchronize using Incoming mode and ensure that there are no conflicts, and merge them locally if there are.

Right click the task context change set (or the project containing the patch--patches should be made for a project, not a file), press Team -> Create Patch and select Save to clipboard.

In the Attachments section of the Task Editor select Attach File... and use Clipboard as the source. Check off the Patch and Attach Context checkboxes in this wizard page.

Add a description of issues addressed and comment on what testing was done to validate it (e.g. unit test coverage, manual tests performed). Also indicate any changes made to the existing UI in the comment (e.g. reordering of menu actions). Also indicate if patch is intended to resolve bug report or further work is required.

Writing Tests

Writing tests along with patches is key to ensuring that it is possible for committers to maintain the new functionality added by the patch. When writing tests look for the All<component>Tests class in the tests plug-in for that component, identify a test that is similar to the functionality that you are adding, and use that test as an example of how to add additional coverage. Tests can sometimes take longer to write then the change itself, but a committer will always be willing to assist you in designing the test or extending the mock test harness to make it easier to write.

The key things to ensure is that your test covers is the addition or change to the existing functionality. For API changes it is often sufficient to have the public method covered. When writing tests for UI components, the simplest way of testing will often involve a combination of unit and black-box testing, for example, relying on other parts of the Mylyn UI to be set up (e.g. the Task List view). Consider the case of adding functionality for pre-selecting a repository in the New Task dialog, writing a test can take the following form (refer to NewTaskWizardRepositorySelectionTest):

Create a mock repository

Add a task to the mock repository

Set the selection on the Task List (new functionality uses this selection)

Invoke the wizard and assert that the selection was set correctly on the viewer (wizard is a black box, all we care about is the contents of the viewer)

Dispose the wizard dialog, remove the mock repository and the mock task

When writing UI tests note that asynchrous updates, such as refresh, can make testing challenging. Note that several UI components have a method on them to set synchronous execution for the purpose of testing, and if such a method is lacking it can be added.

TODO API x.y: This API is going to change for version x.y. Should include a description how it is going to change.

TODO e3.4: Make a change in the future specific to an Eclipse version.

XXX: The implementation uses a temporary work around that should be replaced by a proper solution in the future.

XXX SDK: The code uses internals of the Eclipse platform.

FIXME: Should only be used in very rare cases as a reminder that the marked code does not work as expected. Code marked as FIXME should not be distributed in a release.

FIXME REVIEW: Review the code before the next version is released

Graphics

If contributing a feature with icons or other graphics feel free to ask a committer to generate the graphic for you. If interested in contributing graphics you can find all of the source files (e.g. Photoshop) here: mylyn/graphics/ui.

Committers

Participation

Read the newsgroup regularly, and respond to posts in their area of expertise.

Respond to mylyn-dev email in their area of expertise.

Watch and update all wiki pages related to components that they contribute to.

Communication

Mylyn committers are required to follow these communication guidelines. Our philosophy is that the user is always right, even if it takes time to figure out how or why they are right. Our project thrives on the feedback of users, whether they are seasoned experts or newbies. Feedback defines how the tool should work, how it should be simplified, and how it should evolve.

All feedback contains information, and it is the responsibility of committers to turn that information into actions. This can mean improving the implementation, simplifying the workflow, clarifying the documentation, or noting a duplicate request. Making the actions we take clear helps communicate this philosophy to our growing user community and encourages high-quality feedback.

If users do not provide enough information or do not take the time to provide accurate information, they should be prompted to provide the necessary details. If they do not do so in a timely manner, the feedback is incomplete and can be resolved without taking action.

Show respect to others in the community, whether they are making correct or incorrect assumptions about the tool or technology. When someone makes incorrect assumptions it is because we have not done our job well enough, or because the platforms we build on are making it hard for us to do our job well enough. Identifying those cases is important so that we can provide feedback to those platforms and find work-arounds.

Never turn feedback or discussion away by flaming, being condescending, short, or insulting in any community communication forum. Forms of humor that work for face-to-face communication, such as sarcasm, are usually best avoided because they can result in misinterpretation, especially when there is a language or cultural barrier.

Handling Inappropriate Communication

In the vast majority of cases, following the above guidelines has lead to the high quality communication that our user and contributor community has thrived on. However, the openness of our communication channels has been abused in the past. These scenarios are typically marked by overly opinionated, non-technical and insulting posts on bugs in and in other forums. The communication may have technical elements or technical points, but the points are communicated in an overly opinionated way with a disregard for the opinions of others involved in the dialog. If encountering such communication, make sure to read the Wikipedia Entry on Flaming, especially the "Causes of flaming" section.

Note that invoking the process listed below should be the exception, and not the rule. Projects with like-minded committers can experience the Groupthink bug, which is why high quality open communications channels are so important to helping the project evolve. However, abuse undoes the openness that we strive for by making the channels intimidating or unfriendly to newcommers. Follow these steps if you encounter such communication:

Make one or two attempts to steer the conversation back on a technical path.

If that doesn't address the problem, enter the following text as the third comment:

Bugzilla

Any user-reported bug should be resolved by one of: code improvements, documentation/FAQ improvements, or being marked a duplicate of another bug. All but the last require attaching a context.

Be judicious in marking bugs for LATER, because this typically communicates that the bug will never be resolved. Do this only if the bug does not fit in with the current scope of the project but is related to the mission. Otherwise mark P4/P5 and "helpwanted" to encourage a contribution that is not part of our current prioritization and plan.

When naming bugs, try to describe the use case or problem instead of the implementation unless there is no ambiguity in how the fix should be implemented. If the implementation approach helps with queries append it.

Use the Eclipse bug severity with this exception: bugs marked as Trivial are enhancements, that can be easily implemented.

Keywords

helpwanted: bugs that are beyond the current priorities for the project. Note that some bugs marked for an upcoming milestone can be marked as helpwanted. This indicates that the project committers would like to see the bug solved for the milestone and will actively contribute to a solution, but that the bug is more likely to be fixed in a timely manner with the help of additional contributors.

bugday: these are a special category of helpwanted bugs that are intended to be mast accessible or rewarding for new contributors interested in helping the project to tackle. See the Bug Day FAQ for more information. In order to keep this list focused on the most relevant bugs it is capped at 24 and should be reviewed periodically.

contributed: bugs that were resolved through a contribution from a non-committer.

plan: bugs that are part of the project plan (see below).

Tags
The project uses the following tags in the summary of bugs on bugs.eclipse.org (bug 215853):

Triage

The goal of bug triage to minimize the overhead for committers and to maintain a manageable backlog. Each (new) bug that is filed is processed as follows:

Major bugs or regressions are marked P1. If necessary the bug is escalated and scheduled for the current milestone.

Other bugs are marked P2.

Enhancements requests that should be considered for a future release are generally marked P3.

Other enhancement requests are marked P4 and tagged as helpwanted if they can be resolved through a community contribution.

If a request is out of scope of the project it is marked P5 or preferably closed. P5 bugs should not be marked helpwanted.

The backlog consists of all tasks scheduled for -- with a priority of P2 or higher. User stories are tagged with the plan keyword.

Bugs are assigned as following:

mylyn-inbox@eclipse.org: New bugs are and bugs that need user input.

mylyn-triaged@eclipse.org: Bugs that have been responded to and severity and priority has been set.

other: The owner is committed to completing the task for the scheduled milestone or within a reasonable time frame in the future if the bug is scheduled for --.

Planning

The goal of planning is to schedule a list of bugs for the milestone that concludes the next release cycle. When the milestone is reached all bugs with a priority of P3 or higher are expected to be completed. It is important that planning takes existing resources into account to avoid over-committing. Predictable release deliverables will enable integrators to plan their own progress based on the Mylyn framework and aid the growth of the ecosystem.

Before every release planning is done by triaging the entire backlog. Bugs marked with the plan keyword become part of the official release plan. Planning bugs marked P1 are committed items, other bugs are proposed items. Half way through a release cycle the plan is reviewed and P1/P2 bugs in the backlog are reconsidered for the milestone to accommodate for regressions and major bugs that were submitted after initial planning.

Resolving

The list of bugs that are scheduled for a milestone serves as a log that documents changes to release artifacts. In order to preserve historical information captured by the change log bugs that have been resolved should not be moved to other milestones once a milestone has been released.

If a defect reoccurs or a bug requires further work a new bug should be created and linked to the resolved bug. It is recommended to add a comment on the resolved bug that points to new bug and describes the reason for its creation.

The rationale of excluding repository tests on older Eclipse versions is that running the full suite of repository tests is expensive and a Bugzilla test that fails on 3.5 is very likely to also fail on 3.7.

mylyn-integration-standalone - Java 1.6 : Tests designed to work outside of an OSGi environment

Feature Maturity

Mylyn features vary in UI maturity and availibility of support. The following is a guideline for what it takes to move from experimentation through to maturity. (Note that this is partially based on the Eclipse project lifecycle and could converge further with that lifecycle if Mylyn were split into a separate incubation project or subprojects.)

Mature: packaged Eclipse downloads and available via main update site

UI quality: Eclipse SDK features have set a very high quality and UI consistency bar that needs to be met in order to make it possible to improve users' productivity with Eclipse.

UI simplicity: the Mylyn project's goal is to simplify and streamline the user experience. A simple and self-evident UI also helps ensure a manageable support burdeon on the component.

Availability of support: the feature must have an owner or organization with a long-term commitment to the quality of the feature and the ability to provide responsive support for feedback on that feature.

Responsiveness to feedback: the feature owner and other contributors must process and prioritize user feedback and respond to the highest priority needs in a timely manner (e.g. blockers and critical bugs need to be fixed within one release of being submitted, key enhancements help the feature evolve to meet users' needs).

Incubation and Sandbox: available via the Incubation update site

Unsupported components used for experimentation and not intended for daily use.

Community interest and contributions determine which experimental features move from the Sandbox into Extras.

Applying Patches

Make sure to update mylyn-iplog.csv with an entry for each bug that is resolved by patch. Note that each patch should not contain more than 250 lines of code of unique and seprately usable functionality. For larger patches we need to invoke the IP Review process.

Contributors frequently write quick patches in order to get something working for them. It is the responsibility of the committer to either encourage the contributor to improve the modularity and test coverage of the patch or to do those themselves if this aligns with the projects' priorities. Failing to do so can reduce the overall quality of the code and failing to get sufficient test coverage reduces our ability to evolve the code.

Creating new plug-ins

File a bug that describes the purpose of the new plug-ins and the proposed names. Then add an item to the weekly meeting agenda to discuss the request with other committers. Once consensus has been reached follow the steps below.

Checklist for creating a new plug-in:

Copy an existing project in your workspace to retain all standard settings

Use Team > Disconnect and select delete CVS meta-data

Add desired content to project

Use Team > Share to commit project to CVS

Update PSF files in mylyn/dev/doc

Update map files in org.eclipse.mylyn.releng/maps

For plug-ins:

Add to existing feature

Add source bundle to SDK feature

Add build.properties entries to generate source bundle to SDK feature

For features:

Update org.eclipse.mylyn.releng/config/allElements.xml

Update org.eclipse.mylyn.releng/config/*/site.xml

Send notification to mylyn-dev

Web site authoring

Create a new CVS location: :pserver:dev.eclipse.org:/cvsroot/org.eclipse

Check out www/mylyn as a project

You need to be a member of mylyn-home to commit changes to the website.

Building a distribution

Check out the org.eclipse.mylyn.releng project.

Customize the build to your local environment following instructions in the README.txt file.

Run ant to build release artifacts.

The Release Howto describes how to build and publish official Mylyn releases.

Sandbox

The sandbox is a set of CVS projects and feature contributors use for experimentation. These features are not intended to be used for daily development. Sandbox features include experimental connectors and bridges, experimental UI features, and developer tools. To use sandbox tools either check them out of CVS from the org.eclipse.mylyn/sandbox directory, or install them using the update site above. Please note that some Sandbox tools may have external dependencies, listed in a readme.txt file.

Dev tools

Introspect Object (action): displays the class and other relevant information (e.g. degree-of-interest, task synchronization state) of any object visible in the workbench. Appears at the end of the context menu for any view that accepts an object contributions.

Experimental tools

The following experimental views can be opened via the Experimental view category or accessed via the Tasks -> Experimental preference page.

Task Trim Widget: Shows the active task.

Context Search: Automatically finds and displays elements that are structurally related to landmarks in the active . These elements become part of the task context and have a predicted degree-of-interest.

Context Hierarchy: Displays the Java hierarchy of all landmark elements.

Predicted interested for Java errors: Potentially useful, but tends to overload the Package Explorer. If you find this useful for long-term use condiser commenting on bug 107542.

Tips and Tricks

User support

Every time that you find yourself formulating an answer to a bug report, email, or newsgroup post, if the answer is more than a sentence, consider updating the FAQ, User Guide, or Integrator Reference and pointing to the entry.

Every time that resolving a bug does not result in a code change that addresses the problem or clarifies the UI, update the FAQ or User Guide to make sure that users can self-diagnose the problem. This is particularly important for bugs marked INVALID or WORKSFORME.

Code

For error handling use StatusHandler and pass an IStatus object. Note that some of the other Mylyn code uses the convenience methods on StatusHandler, but we are phasing those out because they do not pass the plug-in ID that the exception originated from.

Use WorkbenchJob for running jobs that should only run when the workbench is active. Not doing this can cause errors on workbench shutdown (e.g. bug 178409).

When using String.toLowerCase(), use String.toLowerCase(Locale.ENGLISH) to ensure locale safety (see bug 168652).

Do not use @Override annotations on implementing methods, only on overriding methods. Doing so violates Java 5 (bug 173171).

Use DateFormat with extra caution. It is not thread-safe and should not be saved to fields in classes that can be used from multiple threads (UI, asynchonous execution, or jobs).

For the sake of multi-monitor setups, use getMonitor() instead of getDisplay() when you want to position a UI element on a specific coordinate of the screen.

To improve the speed of decorators use setUseHashlookup(true) on all structured viewers.

Bugzilla

Query setup: If you are added to the cc list on a report that is not picked up by your usual queries it may go unnoticed. One trick is to create a query for ALL products except the product you usually work in (and hence have queries for) and set the cc field of the query to your id. Now you will be notified of anybody adding you to the cc of a product you don't usually monitor.

JDT

Including Platform plug-ins in search: Java search (Ctrl+H > Java Search) will include all plugins in your Plugin-in Dependencies. If you want to search other plugins as well, open the Plug-ins view, right click on the desired plugin(s) and choose 'Add to Java Search'. That plugin will now always be included in your java searches.

Debugging

Task List problems: do not ask users to send or attach their Task List, since it can contain highly sensitive information. If needed ask the user to create a new workspace and try to reproduce the problem there, ensuring that they have not included any user private or company private information, and have them send that.

Plug-ins fail to load: verify that plug-in dependencies are met via the Validate Plug-in Set button on the launch configuration Plug-ins tab.

Startup failure: If you get an IStartup failure message or a ClassNotFoundException on startup this is often the result of some step in the activation of the plug-in failing.

Attempt to find the earliest exception thrown within the in the plug-in's activation process. For example, this could occur in TasksUiPlugin.start() or TasksUiPlugin.<init>.

If the cause of the failure is not straightforward, the problem could be due to a class loading race condition. This can sometimes be verified by trying a different VM like IBM's or BEA's and checking if that resolves the problem. If this is the case, please file a bug.