ARIA FtF Day 1 -- 22 Sep 2016

<MichielBijl> scribe: MichielBijl

mhakkinen: something that has impacted assessment community, pronunciation by synthetic speech.
... we’re looking on guidance on how to ssml into ??
... we get a lot of non-native speakers who need correct pronunciation.

richardschwerdtfeger: you’re looking to send it to the speech API?
... should get joanie in this room

mhakkinen: we need to get our content rendered as students and teachers need them
... Apple has own speech markup, not as sophisticated as ssml, but we can work with it

richardschwerdtfeger: if we put the ssml in the markup, what happens with Apple?

mhakkinen: we want Apple to support ssml
... can we add attributes containing the ssml?
... we can come up with own data model
... you don’t want ssml inline in html
... attribute model would be nice
... in context of ARIA, would be nice as a web platform thing

richardschwerdtfeger: you mention HTML, but would also want SVG?

mhakkinen: all content that should be hinted in some way, we would like these attributes

janina: IBM TTS is the only speech dispatcher (apparently)

jasonjgw1: if we’re looking for a standard solution and want to share with dpub
... is it desireable to develop in context of ARIA?
... or rather develop it somewhere else?

mhakkinen: if not here, we’ll look somewhere else

richardschwerdtfeger: don’t think it’s an ARIA thing

janina: ever platform has their own speech API
... little bit of a chain for each platform

jasonjgw1: has to go through all sort of systems, AT, speech API, etc

mhakkinen: how does that ssml mark up get to the speech API

richardschwerdtfeger: it’s like you have a semantic block that isn’t displayed

mhakkinen: what we’ve done is two attributes, one for ?? and one with a phonetic string.

mck: isn’t that supported in CSS speech model?

mhakkinen: some, but not all
... everything we need is in SSML, but not in CSS speech model

joanie: if it worked would your problem be solved?

mhakkinen: in that case I would like people to support CSS speech

jasonjgw1: even though you can insert generated content, you can’t do ??

mck: or we need a way to include SSML in the HTML

richardschwerdtfeger: you want a block of content?

mhakkinen: we’ve been able to do all we need with SSML via this attribute model

richardschwerdtfeger: so for one element you have a pair?

mhakkinen: yes

richardschwerdtfeger: suppose that’s doable

mhakkinen: yes, we can do it this way, but how do we get it to both speech API, help text, etc.

richardschwerdtfeger: you would want to map it into the platform
... we can hook up with text help

mhakkinen: we’ve spoken to them

richardschwerdtfeger: I know Glen Gorden wants to do more for the education sector

joanie: what is going through my head, and not been discouraged, if there is a use cage for this, and you can get this in CSS
... and every other AT has to support it as well

mhakkinen: we want the AT pick this up, we don’t want other voices

janina: they want AT to actually use the SSML

jessebeach: have you considered the ruby element?

mhakkinen: ?? visual component
... I don’t think it’s an option at all
... the web speech API is supposed to accept and consume SSML
... we’ve gone through multiple models, most people prefer the attribute model

richardschwerdtfeger: do you have a proposal we can look at?

joanie: we have three things to remember, one, if I support this, how do you know it’s not going to interrupt speech?
... we have to send it as separate info to the synthesiser.
... you said we need this now, with thousands of kids out there

janina: different words might need different pronunciation in different context.

richardschwerdtfeger: we’ll pick this up later

joanie: if you could e-mail them to me (about mhakkinen slides)

richardschwerdtfeger: Sharon you’re here for EO

Education Outreach and the APG.

mck: little background on how this got started
... people expressing concerns with difficulty on how to use ARIA correctly
... lot of different ways on how to reach the developer community
... we need to make sure that it (APG) complements what is out there
... Three things
... 1. what would the goals be of the collaboration
... 2. Identifying some of the resources that already exist and updates to those resources
... have done a bit of that, so have some stuff for us to consider
... 3. how do we want to collaborate

mkc: maybe some of that will become clear if we talk about the goals

mck: I have three proposals for goals
... would like some feedback to see if these are appropriate
... first is creating awareness of the APG
... maybe using existing channels available to the W3C
... second, W3C resources should be consistent with APG and vice versa
... third, plan for the APG should be complete
... milestones are about 80% complete now
... having an outside set of eyes looking at the milestone plan would be good
... does this sound good to everyone?

Sharron: all of this sounds consistent with what we do and how we opperate
... nothing comes to mind immediately on how to improve this list
... are you thinking mostly throughout the W3C or the industry?

mck: more the industry
... there is all these resources, planning web accessibility etc

Sharron: one of the things we found, our own goal, was to promote WAI resources
... we’ve realised that we need to promote it to the outside world
... but have also seen a lot of WGs within W3C also aren’t aware of WAI or APG

mck: everyone on internal is also external

Sharron: *laughs* yes

mck: I would like to take some time to look at a couple of examples
... see EO at the footer of a lot of documents

Sharron: maybe I should tell you more about the process
... we go through the document
... and then it sits there for a while till somebody has time
... we have a schedule for all documents within WAI
... are all assigned to someone
... at least reviewed anual
... there are 80 resources, so takes a while to get it all of the ground
... seems we’re getting ready to publish some of these revisions

mck: it’s a good thing

Sharron: we still have a little bit of coördination with staff
... publication is only done by staff

yatil: we can publish stuff pretty quickly

<mck> https://www.w3.org/WAI/intro/aria.php

mck: one resource linked to in a lot of specs

Sharron: we have so much documents in the EO docs that is outdated or wrong
... we’re also in the process of re-designing the WAI pages

yatil: we might even use ARIA

richardschwerdtfeger: so Sharron, your team is also doing ??
... I don’t want a repeat of ARIA 1.0

Sharron: have recruited three new participants

would be nice to have people from member organisations to participate

yatil: WAI is wheelhouse of knowledge and doing stuff

ARIA is techniques, but not just that, it’s a guide

bring over stuff from APG to WAI(?)

Sharron: we have ARIA throughout most of the stuff we have

yatil: basically want to make tutorials for ARIA

people that know what ARIA is, but don’t want to do a deep dive, could use a tutorial

mck: new APG uses this approach

not written in tutorial way

are code examples

for example to make sure that AT functions with it

where ever possible reference instead of recreate

alastairc: I work with large resources, we have a calendar of content

to give you an overview of what’s coming up

<alastairc> Example: http://maadmob.com.au/resources/content_inventory

jamesn: I see that EO can contribute a lot to ARIA

but we don’t want EO documents should focus too much on ARIA

WAI resources are too easy to understand

All: *laughter*

yatil: if we can make a clear line, this is the simple approach, can say look at APG for complicated example

richardschwerdtfeger: to what degree are you incorporating videos in your education?

Sharron: I can say that we produced a short series of videos

we haven’t used videos at all in other resources

mostly resource/budget issue

but if it’s helpful, we might have to put it into consideration

richardschwerdtfeger: if you can look into it that would be great

thought of doing one for the quick reference

yatil: do we do a screencast, or a lecture

MichielBijl: screencast would be better, lectures take too much time

yatil: also need to think about audio description, might be cimplicated

mck: what might be useful, we have these APG example pages, but for somebody that is relatively new to accessibility and screen readers.

a 2-3 minute video of somebody using that example with a screen reader

to show what the expected behaviour is

might be something that is easy to produce

MichielBijl: sounds pretty good

Sharron: have to remember that a 5 minute video often takes days to produce

richardschwerdtfeger: ARIA has been doing a couple of models
... doing a best practices on SVG

Sharron: think that’s a good place

mck: might want a separate SVG best practices

MichielBijl: how would that work with the new CSS best practices

mck: difference is, apg is on how to use ARIA in another language

so there is a difference to the CSS thing, that is just CSS language

MichielBijl: yeah that makes sense

MichaelC: are we talking about moving content from APG somewhere else, or other content into APG?

<Zakim> MichaelC, you wanted to ask about relatioship between APG and other types of best practices

richardschwerdtfeger: there is other things going on like dpub using ARIA, so maybe something on how to use ARIA to create accessible books

mck: back to the WAI-ARIA overview, it doesn’t have a github repo assigned to it

Sharron: yatil can setup a repo

yatil: will also remove ARIA primer from the nav

All: *cheers*

Sharron: can put in wiki that these are view of APG or EO.

mck: before we go there, I want to make sure that you know what our plan is

<mck> https://github.com/w3c/aria-practices/milestones

mck: so have four milestones

next public wd is in fourth quarter

then we have PR, will miss some more complex examples

we will have a second release with those missing examples and fixes

We have a 2.0 milestone where we assign things as they come up

As we are working on collaborating with other documents

Rasing issues is the best way to bring it to our attention

yatil: what would we do if we wrote a tutorial

mck: best thing would be to mention James, Michiel, and me in the issue

Or send me an e-mail and ask if we can add it to the agenda

jamesn: any reason you don’t want wider ARIA review?

yatil: review outside of APG is fine

jamesn: not sure it’s an APG job

<MichaelC> ARIA contributors

mck: would be awesome if we could assign issues to you guys
... if we have feedback on your documents

would you need us to open GH issues?

Sharron: yes

yatil: every resource that is under EO, should have a repo, if not, contact me

Sharron: we have 80 resources, some of those are multi page

mck: you don’t have them lumped together right?

yatil: some, like tutorials, because they’re considered one resource, but other are all separate

mck: what is the timeline for the redesign?

Sharron: hope to have the first things done by March

like smart search and some visual changes

mck: how do we see the progress in the meantime

yatil: we have a closed basecamp, but there is stuff on the mailinglist

best way is to follow the mailinglist at the moment

richardschwerdtfeger: almost time for break, we will look at mhakkinen’s examples later today

<br>

<jasonjgw_> scribe: jasonjgw_

Accessibility Object Model

<jcraig> https://discourse.wicg.io/t/contributing-the-accessibility-object-model-specification/1702

<jcraig> https://github.com/a11y-api/a11y-api/blob/master/explainer.md

James: he and Alice Boxhall are here to present work on the AOM.

James acknowledges contributors and reviewers who have influenced this work.

James notes the problem of intention events, which also relates to the work of the former IndieUI Working Group.

<aboxhall> chrome.automation: https://developer.chrome.com/extensions/automation

He further notes work on the shadow DOM.

<aboxhall> Mozilla a11yapi: https://github.com/WICG/a11yapi

<aboxhall> WAPA: https://rawgit.com/cyns/wapa/master/wapa.html

He further notes the accessibility API proposals for the Web that have emerged recently, all of which are attempts to solve the same problems.

The current effort was discussed at a face to face meeting in May and has been developed since hten.

He notes the challenge raised by in-document idrefs - problematic in the presence of shadow DOM.

Rich text editors are infeasible to implement/represent in ARIA. Retrofits for these applications to support ARIA are complex and inconvenient.

The initial focus is on solving the problems that are already addressed on the various platforms but not on the Web yet.

There is an expectation that all features must receive browser feedback form at least two different browser implementation developers.

Privacy: user details will not be exposed to applications from this API.

Responding to a questoin from John, he clarifies that this assumption avoids the privacy issues raised by IndieUI work.

The code (that implements the API in applications) must be easy to author.

The intended audience is expected to be framework developers, accessibility engineers, JavaScript accessibility consultants, etc.

Alice: outlines the process by which interactive controls (e.g., buttons) are represented in the DOM, reflected in the accessibility tree maintained by the browser, then communicated to assistive technologies via platform-level APIs.

AT can also activate a button via the accessibility API, resulting in a click event generated by the user agent.

In contrast, a request to change the value of a slider cannot be implemented beyond the point at which it reaches the UA.

The first objective to be implemented is that of modifying accessible properties. Next stage: responding to accessibility-related events. Virtual accessibility nodes with no corresponding DOM nodes. Introspecting computed accessibility tree (phase 4).

Phases 1-3: analogous to a style attribute, where the attribute's value reflects the author-specified value, not the computed value applied to the document. Similarly, the API will initially reflect specified values.

Alice notes how the API can implement object references to other nodes in the accessibility tree.

Alice notes the significance of the shadow DOM for containing rendering details of elements. Example: a custom combo box (i.e., custom element), where the custom element has an associated shadow root and the elements comprising the custom combo box are in the shadow tree.

The options in the custom combo box element are not shadow nodes - they're in the DOM of the containing document, not in shadow DOM. this raises the problem that it is impossible to refer to elements outside the shadow tree using idrefs on shadow tree elements.

<jcraig> Pasting in Slide content:

Alice provides an example of how the API (which solves the above problem and others described above) works to change the roles of widgets (e.g., from button to link).

<jcraig> Agenda

<jcraig> • History: previous proposals and vendor discussions

<jcraig> • Common problems for noticed by browser vendors

<jcraig> • Considerations for scoping

<jcraig> • Audience for this technology

<jcraig> • Example interactions

<jcraig> • Tightly-scoped, phased development plan

<jcraig> • Code samples and demo

<jcraig> • Q &A

<jcraig> Common Problems

<jcraig> • DOM manipulation requirement of ARIA can perform poorly with large datasets

<jcraig> • Reliance on in-document IDREF prevents some usage (e.g. Shadow DOM)

<jcraig> • No way to receive accessibility events (e.g. increment a custom slider)

<jcraig> • Some complex office suites (Google Docs, iWork for iCloud, etc) are challenging to make accessible through standard techniques: POSH+ARIA doesn't cut it.

<jcraig> • Bonus: Accessibility Inspection and Testing

<jcraig> Considerations for Scoping

<jcraig> • Release cycle must be phased, and each phase must be achievable

<jcraig> • Features must be implementable and have positive interest from 2 browsers

<jcraig> • Implementations must not expose user details (privacy)

<jcraig> • Implementations must not negatively affect performance

<jcraig> • Code must be easy to author *

<jcraig> * Easy [for the intended audience] to author. See next slide.

<jcraig> Audience for AOM

<jcraig> • Primarily experts, such as:

<jcraig> • Frameworks engineers

<jcraig> • Web components authors

<jcraig> • Document suite developers: Google Docs, iWork for iCloud, etc. • JavaScript-fluent accessibility consultants

<jcraig> • Accessibility test tool engineers

<jcraig> • AOM may add convenience for the average web developer, but it’s not required.

<jcraig> Tightly-Scoped Development

<jcraig> 1. Modifying accessible properties

<jcraig> will allow setting accessible properties for a DOM-backed node

<jcraig> 2. Accessible actions/events

<jcraig> will allow reacting to user actions from assistive technology

<jcraig> 3. Virtual accessibility nodes (WebGL, etc.)

<jcraig> will allow the creation of virtual accessibility nodes not associated with DOM

<jcraig> 4. Introspection of the fully computed accessibility tree

<jcraig> will allow reading the computed accessible properties for accessibility nodes

<jcraig> Code Examples

<jcraig> / Standard assignment of ARIA relationship by IDREF el.setAttribute("aria-describedby", "id_ref");

<jcraig> / New. Assigning ARIA relationship by object reference el.accessibleNode.describedBy = [objectRef];

<jcraig> * All syntax is subject to change

<jcraig> Code Example: Shadow DOM

<jcraig> #shadow-root

<jcraig> <x-option id="opt1">Option 1</x-option> <x-option id="opt2">Option 2</x-option> <x-option id='opt3'>Option 3</x-option>

<jcraig> Code Example: Shadow DOM

<jcraig> / Assignment across shadow root boundary in web component const input = comboBox.shadowRoot.querySelector("input");

<jcraig> const optionList = comboBox.querySelector("custom-optionlist"); input.accessibleNode.activeDescendant = optionList;

<jcraig> * All syntax is subject to change

Demo

In the demo, the script overrides the role (changing it from button to link) in the accessibility tree, but the DOM remains unchanged - containing an HTML button element.

James clarifies that the computed role is not yet available through the API.

James's example: switch is a new role; the author should write role="switch checkbox"; which role was applied (switch in newer browsers and checkbox in those which odn't support the new role) cannot be ascertained today via any API.

Responding to Matt, James clarifies that values which the script author has written to the accessibility tree via the API can be queried, but not computed roles/values. API inspection tools can nevertheless be used.

Responding to Rich, James clarifies that in phase 4, the computed role (the in-browser role in the accessibility tree) is what will be reflected in the API.

This is intended not to vary by platform.

Alice clarifies that the values which have been set (in ARIA or the API) can be read, but now the value computed by the browser - until phase 4.

The values set via the API take precedence over those declared in ARIA attributes.

James and Alice develop the analogy with setting the style of an element (using attributes and using the API).

Alice clarifies that, via the API, a query would show a role of button on both <div role="button"> and HTML button elements.

Prior to phase 4 of the project, it isn't clear what values would be returned for properties that haven't been set using the API.

Alice presents a demonstration of a canvas-based slider.

The script adds an event listener to the accessiblity tree that sets the value of the slider, including the value of aria-valuenow.

It is demonstrated using VoiceOver that the screen reader can change the value of the slider using this method.

No keyboard events are involved.

Matt notes that the keyboard events would still need to be implemented for users who don't run AT, but this feature would enable screen reader commands/touch gestures to be used to change the values/state of elements.

Alice clarifies that the proposal (in its early phases) is meant to solve problems that do not have existing solutions; this API complements ARIA.

The scope of each phase is narrowly defined with a view to progressive implementation that can be made available to developers quickly.

Alice notes the GitHub repository to which issues can be submitted.

<MichielBijl> https://github.com/a11y-api/a11y-api

<jcraig> https://github.com/a11y-api/a11y-api/blob/master/explainer.md

James clarifies (answering a question from Rich) that the API spec refers to ARIA for the roles and other property values.

<jcraig> https://discourse.wicg.io/t/contributing-the-accessibility-object-model-specification/1702

Alice notes that the Explainer is the first document to refer to in order to understand the API.

James notes the issues that need to be solved in the spec to address virtual accessibility nodes (those which are not in the DOM tree), event handling (requests from AT), etc.

He also acknowledges the necessity of better debugging tools.

He also notes implementation issues that necessitate division of the work into multiple phases as proposed.

James notes ongoing discussions with Microsoft regarding their position with respect to this work.

James acknowledges the contributors who have commented on the work so far.

<richardschwerdtfeger> scrbe: David-MacDonald

<richardschwerdtfeger> scribe: David-MacDonald

<richardschwerdtfeger> scribe: David-MacDonald2

<MichaelC> scribe: david-macdonald

Cognitive Accessibility Task Force Interlock

<david-macdonald_> test

<David-Macdonald2> Test

<David-Macdonald2> Scribe: David-Macdonald2

Lisa: much research was behind pay walls but we have summarized it
... want user to be able to do things safely

Look at the table if you want to throw anything out

<Lisa_Seeman> https://rawgit.com/w3c/coga/master/gap-analysis/table.html

The tables come from the user research

<Lisa_Seeman> https://w3c.github.io/personalization-semantics/

PERSONALIZATION and user settings is another peice... aria-apart should figure out where they think that belongs

There is a third peice

Rich: has the group decided on a prefix

LS: I don't care, could be aria could be Cogan, could be anything

RS: does it need to be mapped to the a11y api

LS: no

S/Cogan/COGA

<Lisa_Seeman> https://github.com/ayelet-seeman/coga.personalisation/tree/JSON-Script

<david-macdonald_> test

<david-macdonald_> scribe: david-macdonald__

<david-macdonald_> Jason: what about users who rely on a11y API,

<david-macdonald_> LS: many of our users don't know about a11y API

<David-MacDonald3> scribe: David-MacDonald3

Test

IBM might get involved with personization j.singleton@hisoftware.com JSON

S/j.singleton@hisoftware.com

S/j.singleton@hisoftware.com/

RS: what if a blind person wants to do that.

LS: a script runs on load, a buttons can simplify, change things to simplify, such as a home picture instead of home button

RS: we may want to use the aria prefix for anything that affects the dom

Ls: I just want the support, but I don't care about the prefix

<clapierre> http://www.w3.org/TR/dpub-aria-1.0/

<richardschwerdtfeger> http://rawgit.com/w3c/aria/master/aria/dpub.html

Examples of attributes could be things such as... key points, example, note, warning, step, external, offers, advertisement

Rs: we have a a lot of these in dpub

<richardschwerdtfeger> https://idpf.github.io/epub-vocabs/structure/

Example shown... of how to simplify a form

HTML is same but dom has changed

Makes it easier to meet WCAG because we a trying to introduce new Success Criteria

S/begpcause/because

Establishing the priority of what is critical, and how can we show that it actually easier for users

the last sentence is Jason

LS: we haven't done research but we have know facts that complicated information is harder to learn, so simplification is useful. If you can load the symbol that the person is familiar with there is a better chance of success

Thee are intelligent people with discalculia is 6% of population

Numbers don't make a lot of sense to them.

The research is obvious. If you speak to anot English speaker in Spanish they will not understand as well as they would in English

JESSE: so should we at Facebook out a home icon on our Web page

LS: no, it is the user recognised symbol.

JESSE: no commercial we site would allow external downloads

LS it's on the user machine...

LS: we would want to have about 5 libraries for user groups

<Mike_Pluke_> Can't hear!

alastair: I've tested quite a few users with cognitive disabilities... do we also need implementors on board.

Lisa: it would be a browser extension

We don't expect development people to understand cognitive disabilities

Craig: os have a primary button, main button, a subclass of button

S/Craig/ James Craig

<MichielBijl> MB: here is James Nurthen’s original proposal: https://lists.w3.org/Archives/Public/public-pfwg/2015Dec/0036.html

<MichielBijl> (for primary button exposure via ARIA/a11y APIs)

<alastairc> scribe: alastairc

Ian: Have some concerns around adoption, persuading people to include this. Have seen attempts at personalisation before, not wanting to loose control of the site.

Lisa: Trying to risk - manage that with 5 example user-files. The other driver is WCAG 2.1, so having a success criteria about showing alternative success criteria, the personalisation aspect could be easier.

Ian: It could be very fragile though, e.g. removing widths on a nav item, but there are so many ways that it could have been positioned, it could break in many ways.
... Some aspects look quite straightforward, could be implemented very easily. I'd like to see a demo on something like Amazon's homepage, Facebook to work out some of these issues. It isn't unworkable, but will take a lot of testing.

Lisa: There is the semantics that the author puts in, but then the question is whether the user-side script is robust.

Richard: This is a good example of how it might work, but think that it needs to be upto the designers.

Ian: It is also a design thing, not just developers.

Lisa: It could be a matter of using 80% of the functionality on a particular site, could comment out the changes that don't work.

Ian: If all of these attributes are specified in the site, it comes under the control of the site.

Lisa: Have to have the semantics, as the user needs to be in control of which icons are used.

Mike: Looking back 25 minutes, there's no way we can measure the precise effectiveness of these, but there is very solid evidence for use-cases. The execution could vary, but there are definitely benefits. That does need testing to quantify.

JC: Ian pointed out it would be trivial for authors to do if there were a media feature for it.
... APA asked for a similar feature for dpub, there's a possibility for custom media features, over a month ago. That's a concrete path for this.
... Custom media queries would allow for getting to a prototype, might not be the solution, but you could show it.
... Goal of socialising the extension is that you can prove it is worthy. You are requesting some very specific features that aren't suppported by major platform. Some of you have considered me dismissive of this idea in the past, but I'm not opposed to it conceptually. I was dismissive of previous proposals because there was no clear path forward. CSS custom media features might be that clear path forward to [CUT]

Richard: Web pages are very complex, just annotating it might not work. But, would also need a way to validate it would work correctly.

Mat: If people have a cognitive disability can they define their own preferences?

JC: Within the switch control community, there is usually someone to help set it up, then the user can further customise it.

mhakkinen: In the education context, we would hope the student can set it up before testing time!

Lisa: A lot of cog issues are localise, and sometimes are compensated. We were also anticipated starting with templates, perhaps with 3/4 questions that would guide to you a starting template.
... Another thought we're having, once the preferences have been established, anyone else using these semantics could access those preference file (security issues allowing).

<jcraig> where you want to go./

<clapierre> This could also be expanded beyond cognitive to color blindness and low vision disabilities and beyond.

<jcraig> scribe: jcraig

Automated Testing

<ShaneM> https://docs.google.com/presentation/d/1-28KVLhJ6M0RDA96RQG7yn8Mxvfau3mssmQuuogIx98/edit?usp=sharing

ShaneM: automating ARIA testing... TF meeting run by JohnG at U of Illinois

we propsed architecture, then I implemented a prototype. Joanie built the real one which we'd like to demo today (If I get through the slides).

WPT: Web Platform Tests... not difficult to adopt/use

ShaneM: previous ARIA test efforts have been manual. exhausting, not exhaustive.

design to get us thru CR.

that's not the goal of testing... We want to reuse and run often. Continuous integration tests. ATTA == Assistive Tech Test Adaptor

tool pulls testable statements out of the wiki and automatically builds the test *cases*

now we want to build an ATTA for JS for the testing context, and then for every platform (e.g. Mac, Windows, etc.).

slide diagram describing the test runner life cycle

i/o from WPT is raw JSON...

WPT scope of testing is limited to the browser (mostly... ignore WebDriver for the sake of this discussion)

but the tests need to run across browsers/platforms. So the ATTA fills the gap between the WPT (browser) to the specific API test (platform)

i/o is more or less pass/fail

today we are sending pass/fail and any messages (platform-specific error message)

Boaz: Is that a native app that runs on each platform

joanie: Yes. it's like a CLI for Accessibility Inspector

JohnJansen: Yes, ours is platforms specific

Boaz: I love that the i/o from your ATTA more or less could be standardized

ShaneM: There are a lot of ways we coud extend this in the future.

skeletal one demoed here is implemented in Python. Joanie's is too.

Still defining the declaritive model for these tests

wiki link to testable statements:

<ShaneM> https://www.w3.org/wiki/ARIA_1.1_Testable_Statements

Only implemented the refinement for ATK

Still much to be added...

<Zakim> MichaelC, you wanted to ask about the relationship between this test formalism and the mapping specs

This table is describing human-added testable statements (if given this, expect that) and define the platform-specific expectations in a table

<MichaelC> mc: this looks like the mapping tables in the AAMs, but more precise. Is there communication with the AAPI TF about this?

<MichaelC> shane: not yet but there should be.

richardschwerdtfeger: MSAA and UIA2 had to be separated b/c they ended up being too different to coalesce

boazsender_: If given <html block>, expect this platform output, how do you generate the test

ShaneM: I'll answer after the demo
... Joanie's demo is a manual test runner

but the browser vendors can run this on an automated system

in this case, we've selected all WAI-ARIA tests... ("raw" tests)

ShaneM: maybe we should reorg our test directories on a per-spec or per tech
... in the WPT env, if you are running your own tests, you need to run a CLI server, and an ATTA on port :4119 (a11y) cuz we're nerds

<ShaneM> Running the tests looks like this:

<ShaneM> 1) start up the wptserve http server

<ShaneM> 2) start up the ATTA for the platform under test

<ShaneM> 3) access the runner interface of the wpt environment and select the tests to run

<ShaneM> 4) click start

<ShaneM> 5) output shows up

ShaneM: When there are multiple assertions, because we have related assertions for each test

boazsender_: what do you have to assert

ShaneM: reads property assertions
... one result in the logging data, because the pass criteria is different for each platform

joanie: I want to show the TBD list

there are a few builtin features I want to share

TBD tests will dump there entire output, so you can use a TBD test run to make a manual assertion and inform your testable statement

Views the output of a serialized platform-side accessibility object which you can use to make your assertions

<Zakim> MichaelC, you wanted to ask if test sanity checking can / should be done at a different layer than ATTA

ShaneM: the make test script will sanity check the testable statement input

not doing that yet

joanie: sanity check needs a lot more ouput per test... not just failed, but why

I would want a better presentation for all this data

<JohnJansen> q

Explains the ATK dump of this TBD test

<Zakim> jcraig, you wanted to ask how you serialize pointers to other objects? and to ask if implementors have expressed concerns about leaking implementation version details and to ask

jcraig: how you serialize pointers to other objects?

joanie: need an identifier... all platforms are now exposing DOM ID... I think we can pass DOM ID through as relation type.

jcraig: watch out for IDREF across doc bouandaries (web components)

<ShaneM> Possibly permit other ways of specifying the object under test other than its "element" via the id attribute.

jcraig: implementors have expressed concerns about leaking implementation version details

joanie: no concerns for me.. microsoft?

JohnJansen: I think it's okay.. still need to inspect more.

<richardschwerdtfeger> here is the new accProbe repository so that we can look at the MSAA and IA2 bridge code from Java https://developer.ibm.com/open/accessibility-probe/

jcraig: Any security concerns with running privileged ATTA running potentially

ShaneM: WPT environment has a rigorously reviewed

JohnJansen: interesting consideration that should be threat modeled

<richardschwerdtfeger> https://github.com/IBMa/AccProbe?cm_mc_uid=57481999426214672102162&cm_mc_sid_50200000=1474559258

JohnJansen: joanie adding CLI extensions?

joanie: it has a dry run mode... passing straight to ATTA... and debug mode with port and host

richardschwerdtfeger: Is the ATTA written in Python? How does is work?

Joanie: Python3 in mine (Py2 for Shane)
... inspects through python binding for ATK SPI...

ShaneM: NVDA has it's own layer that they implemented.

richardschwerdtfeger: Not one for MSAA/UIA

ShaneM: but I got it form NVDA directly... so we're good
... back to slides

fill in missing testable statements

are there missing event changes (???) in ARIA 1.1 we need to account for?

mck: some event changes related to ???

s/???/aria-haspopup/act-desc/busy

ShaneM: manual mode needs finishing

joanie: need to better present the terminal spew for human readability

ShaneM: need error checking
... need Android and iOS as well
... SVG would also work in this test harness

richardschwerdtfeger: some of the 1.0 tests are dependent on timing and sequential steps

ShaneM: already built into the wiki, but you can write those manually
... tests that get generated are (updates Git repo...)

from the wiki are consindered a step... but the arch allows /n/ steps

basically sequential scripting

ShaneM: "delay 3s" for example would be one step
... shows JS includes for the test harness... ATTA and JS Test Runner

shows source of JSON object serial test steps... or this could take a json.js file passed in

ShaneM: plh suggested know the AAM mappings and generate those testable statements from generic ARIA assertions

JohnJansen: ATTA Microsoft wrote is not as extensive as yours, but they (Edge and Firefox version) are both open-sourced on GitHub

whereever the trees differ, we compared against the spec and filed bugs against Edge or Firefox

<ShaneM> https://spec-ops.github.io/atta-api/

<richardschwerdtfeger> github.com/microsoftedge/a11y

ShaneM: spec for this is on GitHub

<richardschwerdtfeger> http://github.com/microsoftedge/a11y

ShaneM: complex graphics are written in accessible SVG

jcraig: more of this please

joanie: unlike crazy a11y bugs, these are straightforward, so we can coalesce the output

ShaneM: If we can mainstream A11y testing, it would be great

<joanie> what I discovered is that a lot of issues were a single bug. They all need to be separate tests, however.

richardschwerdtfeger: would really speed up testing for CR

jcraig: and for browser continuous integration

<joanie> So what I plan to do is add checks for "known issues" so we can include in the output notations that it's all one bug and provide the bug URL so people volunteering to run tests don't have to work too hard to figure out what is an unexpected failure.

JohnJansen: inside a11y repo, there is an ATTA tool for web dev... run on your site
... targeted manually an ATTA for web devs... with an explainer

group: discussion of pros cons of various API techniques for writing these ATTA tools

joanie: my ATTA limits testing to localhost

JohnJansen: ours runs inside WebDriver

ShaneM: anything else?

richardschwerdtfeger: great job joanie and shane

group: *applause*

<richardschwerdtfeger> scribenick: richardschwerdtfeger

APG Update

MichielBijl: We need more people to be aware of this work
... We took out all the stuff we are going to work on for the December working draft
... There was a lot of outdated stuff from ARIA 1.0
... If people are pointed to the APG on github we would like feedback. Developers are not giving us feedback on things we have not reviewed

jcraig: do each of these patterns reference working code examples?

MichielBijl: I like activating a tab on focus but it does not work on iOS

jcraig: that is listed as composite as optional for tab groups
... it is the way tabs work on Macs

mattking: for a every example there will be functional patterns. These are for the most important ones that people are able see and test

jcraig: I can send you a number of combobox examples
... from facebook

MichielBijl: all of our examples are pure javascript and not component libraries
... we will have a code guide
... we need more actual developers on this to make the examples

mattking: we have 5 people that are contributing code

http://rawgit.com/w3c/aria-practices/master/aria-practices.html

Critical Needs Assessment Space for Speech

mhakkinen: We have a critical need for text is not spoken correctly
... We have looked at SSML, CSS3 & PLS as an effective solution
... We need this precise authoring control and SSML does this at the markup level
... When some state in the US says you have to pause x seconds after something is presented (the rules vary by state) we have to abide
... PLS will let us define standard lexicons
... We need this.
... we picked up 5 SSML alements that are important to us
... say-as, phoneme, sub, emphasis, break
... all of the testing vendors are coming to the realization that they can do it with an attribute model
... epub3 already pioneered that
... a data-attribute model is being explored by some vendors as a solution for custom, built-in AT* assessessment delvery platforms
... Read Aloud for LD and Language Learners
... they took the attribute from the phoneme markeup and name-spaced it into epub
... and it works
... SSML Usage: There are <say-as interprea-as=“ordinal”> …
... CSS3 speech ‘speak-as’ property but not as complete as SSML say-as
... In the wild aria-label introduces other problems
... … we want a standard solution and not a custom solution for each AT
... <sub alias=“World Wide Web Consortium”>W3C</sub>

Common table salt is really <span substitution=“Sodium Chloride”>NaCL</span>

scribe: <emphasis level=“strong” huge </emphasis> bank account!
... SML Usage: Take a deep <break time=“3s”> …

Content - a valid method (that doesnt break rendering) . …

for most of these we can map to Mac

mattking: in instances where people don’t want people modifying their speech you can make it a preference

jcraig: most of these are in legacy speech engines

mhakkinen: if the engines support SSML then we should be ok.
... what we have seen with the web speech api we can see who supports it.
... we are authoring the SSML now

https://github.com/mhakkinen/SSML-issues

<alastairc> https://github.com/mhakkinen/SSML-issues

<mhakkinen_> http://ets-research.org/ia11ylab/ssmltool/

<ShaneM> NOTE: I dont think it actually runs inside web driver. I think they use web driver to connect.... but not 100% certain

<mhakkinen_> http://ets-research.org/ia11ylab/ssmltool/

<mhakkinen_> https://github.com/mhakkinen/SSML-issues

<MichaelC> issue: Work on getting AT to follow pronunciation hints

<trackbot> Created ISSUE-1045 - Work on getting at to follow pronunciation hints. Please complete additional details at <http://www.w3.org/WAI/ARIA/track/issues/1045/edit>.

<MichaelC> associate issue-1045 with product-2

<trackbot> issue-1045 (Work on getting at to follow pronunciation hints) associated with product-2.

<MichaelC> issue-1045: see https://github.com/mhakkinen/SSML-issues

<trackbot> Notes added to issue-1045 Work on getting at to follow pronunciation hints.

https://www.w3.org/WAI/ARIA/track/issues/1045

RRSAgent draft minutes

ARIA FtF Day 1

22 Sep 2016

Attendees

Contents