Minutes: User Agent telecon 26 Feb 2015

from http://www.w3.org/2015/02/26-ua-minutes.html
User Agent Accessibility Guidelines Working Group Teleconference 26 Feb 2015

See also: IRC log  http://www.w3.org/2015/02/26-ua-irc
<http://www.w3.org/2015/02/26-ua-irc>
Attendees
PresentJim_Allan, Jeanne, Jan, Greg_Lowney, Kim_PatchRegretsChairJimAllan
Scribeallanj
Contents

   - Topics <http://www.w3.org/2015/02/26-ua-minutes.html#agenda>
      1. Meeting Next week - CSUN?
      <http://www.w3.org/2015/02/26-ua-minutes.html#item01>
      2. Exit Criteria review
      <http://www.w3.org/2015/02/26-ua-minutes.html#item02>
      3. c) Success criteria that are implemented by extensions can be
      demonstrated by two independent extensions to the same user agent.
      <http://www.w3.org/2015/02/26-ua-minutes.html#item03>
   - Summary of Action Items
   <http://www.w3.org/2015/02/26-ua-minutes.html#ActionSummary>

------------------------------

<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.
 Summary of Action Items [End of minutes]

-- 
[image: http://www.tsbvi.edu] <http://www.tsbvi.edu>Jim Allan,
Accessibility Coordinator & Webmaster
Texas School for the Blind and Visually Impaired
1100 W. 45th St., Austin, Texas 78756
voice 512.206.9315    fax: 512.206.9264  http://www.tsbvi.edu/
"We shape our tools and thereafter our tools shape us." McLuhan, 1964