** What parts of Eclipse are Thread-safe? Is thread-safety documented everywhere?

−

* Should there be other patterns for Concurrency than we know now (Jobs, Runnables, ISchedulingRule) ''Have a look at data binding's Realm class - it's a generalization of the 'UI thread' pattern: to have access to a resource belonging to a realm, you have to call it from within the realm, and the only way to get into the realm is by posting a runnable using Realm.asyncExec. This makes access to resources safe while avoiding deadlocks altogether, at the cost of more complex code if your operation needs to access resources from more than one realm. --BorisB''

** Should there be other patterns for Concurrency than we know now (Jobs, Runnables, ISchedulingRule)

+

*** Boris: ''Have a look at data binding's Realm class - it's a generalization of the 'UI thread' pattern: to have access to a resource belonging to a realm, you have to call it from within the realm, and the only way to get into the realm is by posting a runnable using Realm.asyncExec. This makes access to resources safe while avoiding deadlocks altogether, at the cost of more complex code if your operation needs to access resources from more than one realm.''

−

==== Jobs and Scheduling Rules ====

+

* Martin: Need more documentation: What is thread-safe; what needs a particular lock / SchedulingRule;

** (b) '''coarse-grained: don't do so much on the UI thread''' -- post Runnables asynchronously, or use Jobs

−

* If the "master Job" that's responsible for an operation requires an ISchedulingRule itself (e.g. for guaranteed sequential execution), it cannot call API functions that require other ISchedulingRule locks (because it cannot acquire them while it runs -- locks must be known before the Job runs, but it's often not known what locks will be required)

+

** Don't spin the Event Loop deep down in the Stack

−

* In some situations a job want to use rules that are not known before the job starts. It should be (deadlock) safe, if a job can acquire *one* rule at a time.

+

* McQ: An important outcome of this has to be a '''consistent overall picture'''; need to get above the level where we deal with these things one by one;

+

** Mik: Agree.

+

* Martin: Have 3 concepts for concurrency: Threads, Runnables, Jobs. I personally like Runnables, should we move more to this pattern? Are these concepts sufficient?

+

* McQ: Imagine multiple consumers talking to a particular Eclipse on a Server. In this scenario, everything needs to be very clear about when it can be called and under what circumstances -- need to be completely independent of the Event Loop

+

* Martin: One question is Callbacks; how to request additional information from the client

+

* Jeff: In Distributed Computing (Riena), it's not just Concurrency but also high Latency; suggest '''Futures''' as a potential solution

+

** McQ: One caveat - is this making things too complex?

+

** Jeff: Concurrency is never simple.

+

** Ed: People often ask "Is this xxx thread-safe?" -- even Vector is not really thread-safe depending on its use (get an index and delete the Object later on). A consistent story simplifies things.

+

* Martin: Simplest way of Concurrency seems Runanbles / Executor / Realms. Single un-separable Unit of Operation to be scheduled in a Realm, very simple to understand. Is it hard when multiple Realms are accessed?

+

** Boris: Synchronization between 2 realms can only be one-way (risk of race conditions). It's not very fine-grained.

+

* Kevin: We have too many different Runnables.

+

** Martin: Don't we just have so many Runnables because we declare a separate Class for separate Realms (WorkspaceRunnable, ...)? Could this be simplified with a general concept of a single type of Runnable, running in different Realms?

+

** Boris: Not sure. Now we have SafeRunnable which does a different kind of job.

+

* We are currently not as concurrent as we could be; programming model is difficult because we have many different ways of doing things.

+

* Martin: So, a simpler Application Model would also help getting more asynchronous.

−

==== Verboten: Spinning the event loop ====

−

* +1: BorisB

−

* I regularly see hard-to reproduce bugs that are caused because client code spins the event loop (e.g. by opening a blocking dialog). It would be good to have a set of rules that govern when it is ok to spin the event loop.

−

==== Getting rid of singletons ====

−

* +1: BorisB, KevinM

−

* Title says it all. Singletons are bad.

−

==== Role-based Access and Security ====

+

=== Sessions, Role-based Access and Security ===

* +1: MartinO, KevinM, DaveO

* +1: MartinO, KevinM, DaveO

−

* Role-based Access: Hide unavailable functionality for a user who has access to certain roles only, rather than just denying access

* Jeff: If we ask people to turn on Java2 Security it's a non-starter, too much performance overhead. Role-based access and ability to open Files are two different things. On application level, role-based things can be dealt with in many different ways.

+

* Martin: Really talking about two things here:

+

** (a) '''role-based hiding of UI elements''' with finer granularity than Capabilities, but not necessarily secure;

+

** (b) '''role-based denial of services in non-UI''' on a relatively coarse (per Service / per Request) granularity. Not necessarily using Java Security.

+

* Boris: Some work went into 3.4: Capabilities were invented just for hiding elements (make the UI simpler). People have been mis-using this for role-based access. In 3.4, Capabilities have been worked on, using Expressions to express when a certain activity is enabled.

+

* Jeff: That's great from a UI perspective, but there's lots of stuff to be managed in non-UI

+

* We don't even have a "user" in Eclipse right now!

+

* Jeff: Another aspect of this is when mixing in multiple sessions: connecting to Eclipse on a Server, it gets very pervasive because now the Programming Model needs to support "a particular view" on the Services that are available

+

* Right now, people can easily construct a Command (that's not in the UI) in order to hack around limitations

+

* Jeff: would '''map Roles onto Sessions''', since under the covers the same mechanisms need to be in place

+

* Martin: should there be a Session on roles / security at the Summit?

+

* Talk about it in the context of Sessions. Right now, we just have "the running workbench", ensuring that the bundles one hasn't access to don't load.

+

* Jeff: Matt Flaherty will be at the Summit and will have lots of input

** Should everything be a command / handler / workspace operation? Or do we need a different kind of coupling / bus?

−

* This problem is possibly related to several others: --DaveO

+

** DaveO: This problem is possibly related to several others:

−

** Too many listeners. A richer command bus makes it possible to have everybody listen to the command bus rather than having a hodgepodge of listener types.

+

*** Too many listeners. A richer command bus makes it possible to have everybody listen to the command bus rather than having a hodgepodge of listener types.

−

** Non-UI scripting: If everything is a Command, then the set of Commands that mutate state (or some subset of them that can be made API) can become the set of verbs available in the scripting API. This scripting API can be made available trivially in many scripting languages (ie: using methodNotFound in JRuby). What remains is exposing a DOM for the scripting language to interrogate and for the commands to manipulate.

+

*** Non-UI scripting: If everything is a Command, then the set of Commands that mutate state (or some subset of them that can be made API) can become the set of verbs available in the scripting API. This scripting API can be made available trivially in many scripting languages (ie: using methodNotFound in JRuby). What remains is exposing a DOM for the scripting language to interrogate and for the commands to manipulate.

+

+

* Paul Webster: Command stuff as now gets only part of the way - it's currently serializable already, but doesn't get into any kind of state handling. Commands plus the Undo stack gets a lot but not yet macro recording. Depends on how Actions can be executed.

+

* Martin: don't think about backward compatibility here. Need to lay the architectural foundation to enable macro recording in the future. Define what's the "right way" of plugins to be written such that they are scriptable.

+

** Jeff: Concerned about the Application Model -- if everybody needs to write code in terms of commands it won't work

+

** Ed: Yes, seen this in EMF -- foundations for fine-grained commands are there, but cannot force people to do everything in the context of commands. Invented a "Change Recorder" to listen to changes, and still have it undoable

+

* Security is another concern here -- a system that records everything going on is a security hole

+

* It's a lot of work getting buy-in from all plugins into some Scripting architecture.

+

** If this is part of the "too many listeners" solution, it'll be enough incentive for people to move to it

+

* Martin: then we need some kind of "command bus" or "event bus".

+

* Martin: Application Model needs a common way of exposing state

+

* Kevin: Macros help us drive commonality in our architecture, that we should have anyways -- that's good. But hesitant about complicating our programming model by over-architecting stuff for Macro Recording. Don't want to set this as a requirement.

+

* Boris: For this to succeed, we need somebody to '''look at this in concrete terms'''. How much do I get today if I record everything? What needs to be recorded or what's not as important? Do we need to record resizing views, expanding nodes etc? Another topic is having something like a DOM for the interesting pieces in Eclipse, but that's a separate kind of discussion

+

* Martin: Fear that if this is not a core driver, it won't happen.

+

* Kevin: If shooting for 100% recordability, the weight of it is likely unbearable for plugins. Have actions / commands

+

** Martin: Agree, we should push on a '''"90%" recording solution where user can edit the recorded script afterwards to fill in the remaining bits'''

+

* Boris: '''Discussion is too abstract right now''' -- need somebody who was an expert Emacs user to say how Emacs is better than Eclipse, or an Expert who knows how a different App does macro recording

+

** Kevin: Talked to Tim Wagner -- at MS, a lot of work went into Macro recording and it's hardly ever used

+

** Boris: On the Mac, scripting is probably also not very much used?

+

* Mik: in usage studies at Mylyn, found that the command framework is used by SDK and WTP; made a mapping of all menu Actions that are not a command and map it back to a class; commands are doing really well with the SDK

+

* Ed: very interested in the topic because EMF Change Recorder is very similar

+

* Mik: Mylyn has an interaction event log -- can actually play forward and back, will add to the Notes Wiki

+

+

+

=== Dependency Injection ===

+

* +1: BorisB

+

* See [[E4/Architectural Foundations]]

+

** Closely related to Application Model -- If components (view, editor) shouldn't know about the context in which they appear, dependency injection is a technique for this. Instead of PlatformUI.getWorkbench.getHelpSystem(), have the HelpSystem constructor injected.

+

** Jeff: One of my favorites, has a fundamental impact on the entire Platform in terms of programming model, ease of testing etc.

+

+

+

=== Preference Leveling ===

+

* See [[E4/Preferences]]

+

* We currently have (installation, instance, project) levels, what about user level / role-level Preferences? What about multiple levels of nested projects (see below)?

+

** KevinM: ''I'd like to see this topic be the wider subject of preference management as they are already almost unmanageable for a user. For leveling we have user level ones stored outside the workspace, team based ones shared somehow, skinning level ones likely in a CSS style sheet. To reduce clutter we need a better policy on essential preferences v.s. "it's prudent that there is a key that can be set" level ones which perhaps should go elsewhere such as advanved name/value table. Finally if we're interested in role based then it needs to be a topic onto itself since it spans not just preferences but activities etc.''.

+

* Kevin: Currently just one Preference Store: Don't do a good job separating out User Preferences (to drag around on a USB key) vs Team Preferences (which Jazz is very interested in); others should go into a Stylesheet

+

** Right now, Preferences are almost unusable -- look at this top-down before adding more complexity

+

* Ed: Another problem is that if Prefs are exported, there is no categorization at all; Some Prefs should apply to 100 projects, currently these are duplicated; a way of sharing preferences between projects would be a big win

+

* Martin: Not on the Summit Agenda yet -- should it be merged with others?

** If the "master Job" that's responsible for an operation requires an ISchedulingRule itself (e.g. for guaranteed sequential execution), it cannot call API functions that require other ISchedulingRule locks (because it cannot acquire them while it runs -- locks must be known before the Job runs, but it's often not known what locks will be required)

+

** In some situations a job want to use rules that are not known before the job starts. It should be (deadlock) safe, if a job can acquire *one* rule at a time.

+

+

* Martin: Already discussed this as part of [[#Becoming More Asynchronous]]

+

+

+

=== Getting rid of Singletons ===

+

* +1: BorisB, KevinM

+

* Title says it all. Singletons are bad.

+

* Martin: Already discussed this as part of [[#Eclipse Application Model]]

+

+

+

=== Non-UI Scripting ===

+

* +1 DaveO (see keyboard macros above)

+

* Loading a file into an Editor from the Commandline; other macros executed from commandline

+

* Martin: Already discussed this as part of [[#Macro Recording and Playback]]

+

+

+

=== Verboten: Spinning the event loop ===

+

* +1: BorisB

+

* I regularly see hard-to reproduce bugs that are caused because client code spins the event loop (e.g. by opening a blocking dialog). It would be good to have a set of rules that govern when it is ok to spin the event loop.

+

** Martin: Already discussed this as part of [[#Becoming More Asynchronous]]

+

+

+

=== Avoid Modal Dialogs ===

+

* +1 MichaelS

+

* Too many dialogs are modal, like preferences or the new wizards which often make it impossible to look something up while you enter data into the dialog.

+

** Martin: Already discussed this as part of [[#Becoming More Asynchronous]]

*** ''For many RCP apps, the notion of the project at the user level is itself a problem. We need to separate our need for them as a mechanism for hanging off builders etc, vs. when to surface as a first class user notion. -- KevinM''

+

** Eclipse Projects

−

*** ''Agreed. See 'Build Granularity' below for one proposal. --DaveO''

+

*** Plumbing or user artifact?

−

** Project type/nature, adding/removing ''-- KevinM''

+

*** KevinM: ''For many RCP apps, the notion of the project at the user level is itself a problem. We need to separate our need for them as a mechanism for hanging off builders etc, vs. when to surface as a first class user notion.''

+

*** DaveO: ''Agreed. See 'Build Granularity' below for one proposal.''

+

** KevinM: Project type/nature, adding/removing

** {{bug|35973}} Physically nested projects

** {{bug|35973}} Physically nested projects

** Namespace Resolution for projects with same name in a single workspace

** Namespace Resolution for projects with same name in a single workspace

* Martin: Not discussed due to lack of time. Already a separate session at the Summit, will merge points into Summit agenda.

−

* We currently have (installation, instance, project) levels, what about user level / role-level Preferences? What about multiple levels of nested projects (see below)?

+

−

''I'd like to see this topic be the wider subject of preference management as they are already almost unmanageable for a user. For leveling we have user level ones stored outside the workspace, team based ones shared somehow, skinning level ones likely in a CSS style sheet. To reduce clutter we need a better policy on essential preferences v.s. "it's prudent that there is a key that can be set" level ones which perhaps should go elsewhere such as advanved name/value table. Finally if we're interested in role based then it needs to be a topic onto itself since it spans not just preferences but activities etc. -- KevinM''.

+

−

==== Non-UI Scripting ====

−

* +1 DaveO (see keyboard macros above)

−

* Loading a file into an Editor from the Commandline; other macros executed from commandline

−

−

==== Launch / Debug Enhancements ====

−

* Need a Launch Stepper to execute fine-grained operations, rather than monolithic Launches

−

* Need extendable / modifiable Launches

−

* Multicore Debug Workflow (Pin&Clone, Colored Contexts)

−

−

==== Avoid Modal Dialogs ====

−

* +1 MichaelS

−

* Too many dialogs are modal, like preferences or the new wizards which often make it impossible to look something up while you enter data into the dialog.

−

==== Build Granularity ====

+

=== Build Granularity ===

* +1: DaveO

* +1: DaveO

+

* See [[E4/RCP Future]]

Currently, the bits we build break down as:

Currently, the bits we build break down as:

Line 126:

Line 292:

* Eclipse SDK.....

* Eclipse SDK.....

−

=== Eclipse Application Model ===

+

* Martin: Not discussed due to lack of time. Will move this into a separate Summit topic.

−

* +1 MartinO, BorisB, KevinM, MichaelS

+

−

* See [[E4/Eclipse Application Model]]

+

−

* Why are Workbench / PlatformUI / Platform not part of the initial Application Model? ''Because they are not services in the sense that there could be alternative implementations --BorisB''

+

=== Launch / Debug Enhancements ===

−

** What about SWT, Views, Widgets, Trees, Labels, ... JFace Dialogs, Fonts, Text, Editors... Perspectives... Databinding ''SWT is a library, not a service that could have a different implementation. The same is true (mostly) for JFace and data binding. --BorisB''

+

* Seeding Questions:

−

** Capabilities

+

** Need a Launch Stepper to execute fine-grained operations, rather than monolithic Launches

−

** Content Types, Associations

+

** Need extendable / modifiable Launches

−

** Markers

+

** Multicore Debug Workflow (Pin&Clone, Colored Contexts)

−

** Workspace, Resources (related to Team Support)

+

−

** Launching Framework

+

* Martin: Not discussed due to lack of time. Probably not an Architectural / E4 topic but a matter of evolution.

−

** Core Variables / Launch String Substitution

+

−

** What about EFS (core.filesystem)

+

−

* What about Extension Registry (IExtensionRegistry), IExtensionTracker is not everything?

+

== Executive Summary of the Discussion ==

−

* What about Secure Preferences

+

−

* What about the rest of OSGi (NLS, Services, Bundle States / Activator / Classloader; Log; State Location)

** Besides the List of Services we're compiling now by hand, we'll need a '''strong way of describing the Services''' for E4 -- as a medium for newcomers to understand Eclipse -- perhaps Tooling to make Service Descriptions machine readable / usable

−

'' The other services listed above seem relevant, I will try to add them to [[E4/Eclipse Application Model]] before the call. --BorisB''

+

** Especially when Services go on the Server (Sessions, Macros Recording), need a consistent Story for exposing a Service, its state and commands, need to be [[#Getting rid of Singletons]]

+

** Mik to write Position Papers on new '''Focus Service''' and '''Notification Service'''

+

** Every '''Service should have a Wiki page describing it''' and the Architecture behind it (probably linked from the [[E4/Eclipse Application Model]] Summary Page

+

** Application Model is related to almost all other architectural topics ([[#Too Many Listeners]], [[#Becoming More Asynchronous]], [[#Dependency Injection]], Sessions, Macro Recording)

+

+

* [[#Too Many Listeners]]

+

** For '''too many different listener classes''' problem, the Champions will sit together at the Summit to merge generic Listener concepts from (EMF, DataBinding, others)

+

** For '''too many listener instances''' problem, a general Command Bus / Event Bus may help. Related to Application Model.

+

** Champions to sit together at Summit and merge concepts from (EMF, DataBinding, Others)

+

+

* [[#Becoming More Asynchronous]]

+

** Need a '''consistent overall picture'''; get above the level where we deal with these things one by one

+

** [[#Jobs and Scheduling Rules]] have some problems; Realms and Runnables are good; We have too many Runnables; '''Futures''' could be a solution

+

** Too many different ways of doing things, a more consistent Application Model would help getting more asynchronous

Should there be other patterns for Concurrency than we know now (Jobs, Runnables, ISchedulingRule)

Boris: Have a look at data binding's Realm class - it's a generalization of the 'UI thread' pattern: to have access to a resource belonging to a realm, you have to call it from within the realm, and the only way to get into the realm is by posting a runnable using Realm.asyncExec. This makes access to resources safe while avoiding deadlocks altogether, at the cost of more complex code if your operation needs to access resources from more than one realm.

Martin: Need more documentation: What is thread-safe; what needs a particular lock / SchedulingRule;

(b) coarse-grained: don't do so much on the UI thread -- post Runnables asynchronously, or use Jobs

Don't spin the Event Loop deep down in the Stack

McQ: An important outcome of this has to be a consistent overall picture; need to get above the level where we deal with these things one by one;

Mik: Agree.

Martin: Have 3 concepts for concurrency: Threads, Runnables, Jobs. I personally like Runnables, should we move more to this pattern? Are these concepts sufficient?

McQ: Imagine multiple consumers talking to a particular Eclipse on a Server. In this scenario, everything needs to be very clear about when it can be called and under what circumstances -- need to be completely independent of the Event Loop

Martin: One question is Callbacks; how to request additional information from the client

Jeff: In Distributed Computing (Riena), it's not just Concurrency but also high Latency; suggest Futures as a potential solution

McQ: One caveat - is this making things too complex?

Jeff: Concurrency is never simple.

Ed: People often ask "Is this xxx thread-safe?" -- even Vector is not really thread-safe depending on its use (get an index and delete the Object later on). A consistent story simplifies things.

Martin: Simplest way of Concurrency seems Runanbles / Executor / Realms. Single un-separable Unit of Operation to be scheduled in a Realm, very simple to understand. Is it hard when multiple Realms are accessed?

Boris: Synchronization between 2 realms can only be one-way (risk of race conditions). It's not very fine-grained.

Kevin: We have too many different Runnables.

Martin: Don't we just have so many Runnables because we declare a separate Class for separate Realms (WorkspaceRunnable, ...)? Could this be simplified with a general concept of a single type of Runnable, running in different Realms?

Boris: Not sure. Now we have SafeRunnable which does a different kind of job.

We are currently not as concurrent as we could be; programming model is difficult because we have many different ways of doing things.

Martin: So, a simpler Application Model would also help getting more asynchronous.

Jeff: If we ask people to turn on Java2 Security it's a non-starter, too much performance overhead. Role-based access and ability to open Files are two different things. On application level, role-based things can be dealt with in many different ways.

Martin: Really talking about two things here:

(a) role-based hiding of UI elements with finer granularity than Capabilities, but not necessarily secure;

(b) role-based denial of services in non-UI on a relatively coarse (per Service / per Request) granularity. Not necessarily using Java Security.

Boris: Some work went into 3.4: Capabilities were invented just for hiding elements (make the UI simpler). People have been mis-using this for role-based access. In 3.4, Capabilities have been worked on, using Expressions to express when a certain activity is enabled.

Jeff: That's great from a UI perspective, but there's lots of stuff to be managed in non-UI

We don't even have a "user" in Eclipse right now!

Jeff: Another aspect of this is when mixing in multiple sessions: connecting to Eclipse on a Server, it gets very pervasive because now the Programming Model needs to support "a particular view" on the Services that are available

Right now, people can easily construct a Command (that's not in the UI) in order to hack around limitations

Jeff: would map Roles onto Sessions, since under the covers the same mechanisms need to be in place

Martin: should there be a Session on roles / security at the Summit?

Talk about it in the context of Sessions. Right now, we just have "the running workbench", ensuring that the bundles one hasn't access to don't load.

Macro Recording and Playback

Should everything be a command / handler / workspace operation? Or do we need a different kind of coupling / bus?

DaveO: This problem is possibly related to several others:

Too many listeners. A richer command bus makes it possible to have everybody listen to the command bus rather than having a hodgepodge of listener types.

Non-UI scripting: If everything is a Command, then the set of Commands that mutate state (or some subset of them that can be made API) can become the set of verbs available in the scripting API. This scripting API can be made available trivially in many scripting languages (ie: using methodNotFound in JRuby). What remains is exposing a DOM for the scripting language to interrogate and for the commands to manipulate.

Paul Webster: Command stuff as now gets only part of the way - it's currently serializable already, but doesn't get into any kind of state handling. Commands plus the Undo stack gets a lot but not yet macro recording. Depends on how Actions can be executed.

Martin: don't think about backward compatibility here. Need to lay the architectural foundation to enable macro recording in the future. Define what's the "right way" of plugins to be written such that they are scriptable.

Jeff: Concerned about the Application Model -- if everybody needs to write code in terms of commands it won't work

Ed: Yes, seen this in EMF -- foundations for fine-grained commands are there, but cannot force people to do everything in the context of commands. Invented a "Change Recorder" to listen to changes, and still have it undoable

Security is another concern here -- a system that records everything going on is a security hole

It's a lot of work getting buy-in from all plugins into some Scripting architecture.

If this is part of the "too many listeners" solution, it'll be enough incentive for people to move to it

Martin: then we need some kind of "command bus" or "event bus".

Martin: Application Model needs a common way of exposing state

Kevin: Macros help us drive commonality in our architecture, that we should have anyways -- that's good. But hesitant about complicating our programming model by over-architecting stuff for Macro Recording. Don't want to set this as a requirement.

Boris: For this to succeed, we need somebody to look at this in concrete terms. How much do I get today if I record everything? What needs to be recorded or what's not as important? Do we need to record resizing views, expanding nodes etc? Another topic is having something like a DOM for the interesting pieces in Eclipse, but that's a separate kind of discussion

Martin: Fear that if this is not a core driver, it won't happen.

Kevin: If shooting for 100% recordability, the weight of it is likely unbearable for plugins. Have actions / commands

Martin: Agree, we should push on a "90%" recording solution where user can edit the recorded script afterwards to fill in the remaining bits

Boris: Discussion is too abstract right now -- need somebody who was an expert Emacs user to say how Emacs is better than Eclipse, or an Expert who knows how a different App does macro recording

Kevin: Talked to Tim Wagner -- at MS, a lot of work went into Macro recording and it's hardly ever used

Boris: On the Mac, scripting is probably also not very much used?

Mik: in usage studies at Mylyn, found that the command framework is used by SDK and WTP; made a mapping of all menu Actions that are not a command and map it back to a class; commands are doing really well with the SDK

Ed: very interested in the topic because EMF Change Recorder is very similar

Mik: Mylyn has an interaction event log -- can actually play forward and back, will add to the Notes Wiki

Dependency Injection

Closely related to Application Model -- If components (view, editor) shouldn't know about the context in which they appear, dependency injection is a technique for this. Instead of PlatformUI.getWorkbench.getHelpSystem(), have the HelpSystem constructor injected.

Jeff: One of my favorites, has a fundamental impact on the entire Platform in terms of programming model, ease of testing etc.

Preference Leveling

We currently have (installation, instance, project) levels, what about user level / role-level Preferences? What about multiple levels of nested projects (see below)?

KevinM: I'd like to see this topic be the wider subject of preference management as they are already almost unmanageable for a user. For leveling we have user level ones stored outside the workspace, team based ones shared somehow, skinning level ones likely in a CSS style sheet. To reduce clutter we need a better policy on essential preferences v.s. "it's prudent that there is a key that can be set" level ones which perhaps should go elsewhere such as advanved name/value table. Finally if we're interested in role based then it needs to be a topic onto itself since it spans not just preferences but activities etc..

Kevin: Currently just one Preference Store: Don't do a good job separating out User Preferences (to drag around on a USB key) vs Team Preferences (which Jazz is very interested in); others should go into a Stylesheet

Right now, Preferences are almost unusable -- look at this top-down before adding more complexity

Ed: Another problem is that if Prefs are exported, there is no categorization at all; Some Prefs should apply to 100 projects, currently these are duplicated; a way of sharing preferences between projects would be a big win

Martin: Not on the Summit Agenda yet -- should it be merged with others?

Java 5 Usage

Martin: This is a clearly defined topic, can be discussed at the Summit

Related Topics (Discussed in Other Context)

Jobs and Scheduling Rules

+1: MartinO, MichaelS

Seeding Questions:

Many calls into (workspace, or other contributed) API require downstream locks via ISchedulingRule

It's often not documented what rules / locks a call requires

If the "master Job" that's responsible for an operation requires an ISchedulingRule itself (e.g. for guaranteed sequential execution), it cannot call API functions that require other ISchedulingRule locks (because it cannot acquire them while it runs -- locks must be known before the Job runs, but it's often not known what locks will be required)

In some situations a job want to use rules that are not known before the job starts. It should be (deadlock) safe, if a job can acquire *one* rule at a time.

Non-UI Scripting

Verboten: Spinning the event loop

+1: BorisB

I regularly see hard-to reproduce bugs that are caused because client code spins the event loop (e.g. by opening a blocking dialog). It would be good to have a set of rules that govern when it is ok to spin the event loop.

Other Topics (Not Discussed on the Phone)

Workspace, Resources, Content Types

Pattern Matching for content types rather than just file extensions + stream evaluation

Case sensitive patterns for content types

Project-specific content types

Eclipse Projects

Plumbing or user artifact?

KevinM: For many RCP apps, the notion of the project at the user level is itself a problem. We need to separate our need for them as a mechanism for hanging off builders etc, vs. when to surface as a first class user notion.

Namespace Resolution for projects with same name in a single workspace

Inclusion of files from anywhere (liked linked resource), plus exclusion of elements by pattern (exclude from resource tree rather than just hide) Maybe we should stop assuming that the files are in the same directory tree. Most people think of projects as "the set of things I am working on" not as a physical space on the drive. Linked resources should be the design norm. -- KevinM

Full native support for symbolic links (better algorithms for detecting link cycles and avoiding OutOfMemoryError)

Build Granularity

A lot of RCP applications don't need to be as generic as SWT or RCP. They want a generic container that looks and works like the Workbench. The Platform Project SDK would be ideal for this purpose, but the Platform Project SDK surfaces Build and Debug bits in the UI. I propose the following factoring:

SWT

RCP SDK

Workbench SDK (Does not include Resource Perspective)

Resource SDK (Includes Resource Perspective)

Eclipse Platform Project SDK (Adds debug and build bits we currently have or maybe this goes away?)

Eclipse SDK.....

Martin: Not discussed due to lack of time. Will move this into a separate Summit topic.

Launch / Debug Enhancements

Seeding Questions:

Need a Launch Stepper to execute fine-grained operations, rather than monolithic Launches

Need extendable / modifiable Launches

Multicore Debug Workflow (Pin&Clone, Colored Contexts)

Martin: Not discussed due to lack of time. Probably not an Architectural / E4 topic but a matter of evolution.

Executive Summary of the Discussion

Besides the List of Services we're compiling now by hand, we'll need a strong way of describing the Services for E4 -- as a medium for newcomers to understand Eclipse -- perhaps Tooling to make Service Descriptions machine readable / usable

Especially when Services go on the Server (Sessions, Macros Recording), need a consistent Story for exposing a Service, its state and commands, need to be #Getting rid of Singletons

Mik to write Position Papers on new Focus Service and Notification Service

Every Service should have a Wiki page describing it and the Architecture behind it (probably linked from the E4/Eclipse Application Model Summary Page