<trackbot> Date: 26 February 2015

https://lists.w3.org/Archives/Public/w3c-wai-ua/2015JanMar/0024.html

http://www.w3.org/WAI/UA/work/wiki/Main_Page#Implementation

<scribe> scribe: allanj

open item 1

Meeting Next week - CSUN?

RESOLUTION: no meeting next week

close item 1

Exit Criteria review

https://lists.w3.org/Archives/Public/w3c-wai-ua/2015JanMar/0024.html

<jeanne> https://lists.w3.org/Archives/Public/w3c-wai-ua/2015JanMar/0038.html

follow up from http://www.w3.org/2015/02/19-ua-minutes.html

js: need examples for c) Success criteria that are implemented by extensions can be demonstrated by two independent extensions to the same user agent.

jr: is d. excluded?

js: should be included in the note

jr: is an overarching principle, ok to see it go

<Jan> The goal is to have independent implementations (i.e. different codebases) for each success

js: do we need to add "different code bases"?

<Jan> criteria, while taking into account that other software components that

<Jan> are not connected to the success criteria being tested may be shared.

ja: different code bases = different browser applications - separate from rendering engines

<Greg> Is 1.1.2 really a good example for (a) because a browser's UI may or may not expose this rendering engine behavior.

<Greg> Sorry, I was confused there for a second. This is only for exit criteria, so it's fine.

jr: different code-bases are explained in a) and b)

<Jan> The goal is to have independent implementations (i.e. different codebases) for each success criteria, while taking into account that other software components that are not connected to the success criteria being tested may be shared.

<Jan> +1

gl: not goal but requirement

<jeanne> Implementations features that satisfy a specific success criteria (plugins, extensions or user agents) must be from different code bases in order to be considered independent, while taking into account that other software components that are not connected to the success criteria being tested may be shared.

<Greg> Implementations features that satisfy a specific success criteria (plugins, extensions or user agents) must be from different code bases in order to be considered independent. Other software components that are not connected to the success criteria being tested may be shared.

ja: what does that mean?

gl: can test an SC in 2 different browsers (different UIs) but they may use the same rendering engine.

<Greg> a...criterion or (no a) ...criteria

<jeanne> Implementations features that satisfy a specific success criterion (plugins, extensions or user agents) must be from different code bases in order to be considered independent. Other software components that are not connected to the success criteria being tested may be shared.

<jeanne> Implementations features that satisfy specific success criteria (plugins, extensions or user agents) must be from different code bases in order to be considered independent. Other software components that are not connected to the success criteria being tested may be shared.

<jeanne> Implementations features that satisfy specific success criteria (plugins, extensions or user agents) must be from different code bases in order to be considered independent. Other software components that are not connected to the success criterion being tested may be shared.

<jeanne> Implementations (plugins, extensions or user agents) of a feature that satisfy a specific success criterion must be from different code bases in order to be considered independent. Other software components that are not connected to the success criterion being tested may be shared.

<jeanne> Implementations (plugins, extensions or user agents) of a feature that satisfy a specific success criterion must be from different code bases in order to be considered independent. Other software components that are not connected to the success criterion being tested can be from shared code bases.

<jeanne> Implementations (plugins, extensions, user agents, or rendering engines) of a feature that satisfy a specific success criterion must be from different code bases in order to be considered independent. Other software components that are not connected to the success criterion being tested can be from shared code bases.

<jeanne> Implementations (rendering engines, user agents, plugins, or extensions) of a feature that satisfy a specific success criterion must be from different code bases in order to be considered independent. Other software components that are not connected to the success criterion being tested can be from shared code bases.

c) Success criteria that are implemented by extensions can be demonstrated by two independent extensions to the same user agent.

js: need examples

gl: reword c)

<Greg> Not great wording but here's the idea: Success criteria can be demonstrated by two independent extensions to the same or different user agents, or by a combination of an extension and a native feature in the same or different user agent.

ja: would also add "or plugins" to maintain parallel with note

<Greg> We don't want to imply that an SC has to be addressed by two extensions.

use plug-ins

<Greg> That is, an SC needs to be addressed by two independent implementations, each of which can be an extension or plug-in, or natively implemented in a browser or rendering engine.

<Greg> That is, an SC needs to be addressed by two independent implementations, each of which can be an extension/plug-in, or natively implemented in a browser/rendering engine.

Success criteria can be demonstrated by two independent extensions to the same or different user agents, or by a combination of an extension and a native feature in the same or different user agent.

<Greg> Success criteria can be demonstrated by two independent extensions to the same or different user agents, or by a combination of an extension and a native feature in the same or different user agent, or by native features in two different user agents.

Success criteria can be demonstrated by two independent extensions to the same or different user agents, by a combination of an extension and a native feature in the same or different user agent, or by native features in two different user agents.

gl: combination - native feature, but extension does it better.
... need a description rather than just a listing to explain a, b, c

<Greg> I'm not sure, for example, that Maintain Point of Regard is entirely handled by the rendering engine, rather than the user agent UI being involved. Thus is it really a good example for (a)?

jr: need insider (developer) knowledge as to whether a feature is in the rendering engine or the UI

js: how do we know what is from a shared codebase

<jeanne> X.X.X can have an implementation in the native user agent, and also have an extension that provides a more feature-rich implementation that satisfies the success criterion.

ja: use 1.8.12 Allow Same User Interface instead of 1.8.6

js: by codebase we recognize that 2 different browsers may share a rendering engine, 2 different extensions may share a user agent
... how do we prove different code bases

jr: if 2 different UAs that appear very different...

ja: are there 2 browsers with same UI base but are different browsers?

gl: FF and TOR (copyright free firefox)

<jeanne> Implementations (rendering engines, user agents, plugins, or extensions) of a feature that satisfy a specific success criterion must be different in order to be considered independent. Other software components that are not connected to the success criterion being tested can be from shared code bases.

<Jan> http://dev.w3.org/html5/decision-policy/public-permissive-exit-criteria.html

<Jan> Independent: Each implementation must be developed by a different party and cannot share, reuse, or derive from code used by another qualifying implementation. Sections of code that have no bearing on the implementation of this specification are exempt from this requirement.

<Jan> Implementations (rendering engines, user agents, plugins, or extensions) of a feature that satisfy a specific success criterion must be different in order to be considered independent. Each implementation must be developed by a different party and cannot share, reuse, or derive from code used by another qualifying implementation. Sections of code that have no bearing on the implementation of...

<Jan> ...a success criterion would be exempt from this requirement.

<Jan> Each implementation (e.g. rendering engine, user agent, plugin, or extension) must be developed by a different party and cannot share, reuse, or derive from code used by another qualifying implementation. Sections of code that have no bearing on the implementation of a success criterion would be exempt from this requirement.

js: each implementation of a success criteria...

<jeanne> In order to be considered independent, each implementation (e.g. rendering engine, user agent, plugin, or extension) of a success criterion must be developed by a different party and cannot share, reuse, or derive from code used by another qualifying implementation. Sections of code that have no bearing on the implementation of a success criterion would be exempt from this requirement.

<jeanne> In order to be considered independent, each implementation (e.g. rendering engine, user agent, plugin, or extension) of a success criterion must be developed by a different party and cannot share, reuse, or derive from code used by another qualifying implementation. Sections of code that have no bearing on the implementation of the success criterion would be exempt from this requirement.

gl: concern over "qualifying" implementation.

<jeanne> Success criteria can be demonstrated by two independent extensions to the same or different user agents, by a combination of an extension and a native feature in the same or different user agent, or by native features in two different user agents. Examples include:

<jeanne> X.X.X can have an implementation in the native user agent, and also have an extension that provides a more feature-rich implementation that satisfies the success criterion.

<jeanne> 2.3.1 can have an implementation in the native user agent, and also have an extension that provides a more feature-rich implementation that satisfies the success criterion.

<Greg> Example: A browser has a built-in feature that allows direct navigation to links, thus complying with 2.3.1. If an extension provides a different, perhaps more feature-rich method of doing the same thing, that can count as a second qualifying implementation even if it is for the same browser.

<Greg> Example for

js: concerns
... this draws a very hard line, with no wiggle room

jr: wiggle room is better

Example for (B): Two browsers based on the same rendering agent may both provide the ability to allow pop-up windows (1.8.3) to have the same User Interface as the parent user agent. This would count as two independent implementations, even though the rendering engines are the same.

<jeanne> (B): Two browsers based on the same rendering engine may both provide the ability to replace images with their Alt text. These would count as independent implementations, because the user interface to turn that feature on and off may be implemented very differently in the two browser's user interfaces.

<Greg> Here's my original example that accidentally got deleted from the minutes: Example for (A): Two browsers based on the same rendering agent may both provide the ability to replace images with their Alt text. These would not count as independent implementations, even though the user interface to turn that feature on and off may be implemented very differently in the two browser's user interfaces.

ja: focus on the concrete for a) and b) leave the convolutions of SC with UI and rendering engine components out of the exit criteria

<jeanne> (B): Two browsers based on the same rendering engine may both provide the ability to require pop-up windows (1.8.3) to have menus and scrollbars. This would count as two independent implementations, even though the rendering engines are the same.

<Jan> http://en.wikipedia.org/wiki/Trident_%28layout_engine%29

<Greg> I don't think we have consensus on whether Chrome and Opera (or IE and Tencen's) would count as independent implementations for an SC that is implemented in their shared rendering engine but adjusted through their different UIs.

This is scribe.perl Revision: 1.140  of Date: 2014-11-06 18:16:30  
Check for newer version at http://dev.w3.org/cvsweb/~checkout~/2002/scribe/

Guessing input format: RRSAgent_Text_Format (score 1.00)

Succeeded: s/can text/can test/
Succeeded: s/concents/concerns/
Succeeded: s/(A): Two browsers based on the same rendering agent may both provide the ability to replace images with their Alt text. These would not count as independent implementations, even though the user interface to turn that feature on and off may be implemented very differently in the two browser's user interfaces.//
Found Scribe: allanj
Inferring ScribeNick: allanj
Default Present: Jim_Allan, Jeanne, Jan, Greg_Lowney, Kim_Patch
Present: Jim_Allan Jeanne Jan Greg_Lowney Kim_Patch
Found Date: 26 Feb 2015
Guessing minutes URL: http://www.w3.org/2015/02/26-ua-minutes.html
People with action items: 

WARNING: Input appears to use implicit continuation lines.
You may need the "-implicitContinuations" option.