A user account is required in order to edit this wiki, but we've had to disable public user registrations due to spam.

To request an account, ask an autoconfirmed user on Chat (such as one of these permanent autoconfirmed members).

Change Proposal for ISSUE-129: Difference between revisions

From WHATWG Wiki
Jump to navigation Jump to search
Line 113: Line 113:
We should not make our specifications be confusing, we should not include redundant requirements that are already in other normatively referenced specifications, we should not explicitly state that certain combinations are valid if there's no reason to suspect that they might be invalid.
We should not make our specifications be confusing, we should not include redundant requirements that are already in other normatively referenced specifications, we should not explicitly state that certain combinations are valid if there's no reason to suspect that they might be invalid.


★ I'd like to include something more constructive here but I'm completely at a loss as to what we're supposed to be arguing against here.
We should, indeed, include detailed requirements regarding the constraints placed on ARIA attributes in different situations. For example, it is important that the aria-disabled="" attribute be set to "true" on any control that is disabled (not any control that has the disabled="" attribute specified, which is a different matter). It is important that we restrict aria-valuemax="" when set on INPUT elements in the Range state to the maximum value (not necessarily the value given in the max="" attribute). There are a number of such requirements. The specification requires all the ones that make sense.
<!--'''Summary: '''-->
<!--'''Summary: '''-->



Revision as of 01:38, 14 January 2011

Summary

Don't allow people to use ARIA to write inaccessible documents.

Rationale

The bug titles given below are intended to describe the actual underlying requests or issues raised in the bugs. They do not match the original bug summaries as those were often quite misleading when compared to the actual requests.

General points

The current section defining the relationship between the HTML and ARIA specifications uses an approach eminently suited for addressing accessibility in HTML. It is defined in terms that the ARIA specification uses, provides the information needed by implementors, authors, and validator writers, and provides a coherent and concise set of UA and document requirements.

Conformance criteria must be used to lessen the probability that developers will use ARIA to make their content inaccessible. This can be achieved, for instance, by using them to ensure that when ARIA is used, it is used correctly and in such a manner that will improve the accessibility of the content to which it is applied. The current specification text achieves this: it balances the conformance crtieria outcomes in favour of fulfilling ARIA's role as a technology to "improve the accessibility and interoperability of web content and applications" [1], disallowing ARIA markup that does not make sense, and allowing markup that does. It does not allow overrides of widget roles by unrelated widget roles, or allow overrides of semantic roles by unrelated semantic roles, nor does it allow for overriding of aspects of elements. It allows roles to be overriden by their children in the ARIA role taxonomy where that makes sense, and disallows it where it does not. (The role taxonomy in ARIA is based on a role's features; it does not follow that children are always more specific versions of the same concept. For instance, menuitemradio and menuitemcheckbox are not interchangeable in user interfaces, but in ARIA the former is a child of the latter.)

Bug 10444: Requesting a list of all the elements that do not have a default ARIA role

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10444

  • There's no clear use case for this. Implementors wouldn't benefit (no default role would just be the overall default, so there's no need to list out which specific cases it should apply to). Authors wouldn't benefit (the section is listing restrictions, it's self-evident that anything that isn't restricted is unrestricted). Validators wouldn't benefit (there's nothing to implement if it's not a restriction).
  • An accurate list would be confusing to authors. For example, for each element one would have to explicitly list that it does have a role if the accesskey is set with a valid value that the user agent was able to apply, etc. For elements that have roles in specific situations, like H1 which only has a role when it's not in an HGROUP, or INPUT elements which only have roles when their TYPE attribute is in particular states, the situation is even worse, because the list would have to give all the conditions not matched by the elements when the do have a role. Thus, the list would be extremely opaque and would not be helpful to authors — indeed on the contrary, it would lead authors to thinking the situation was far more complicated than it really is, potentially leading to them not using the features at all, which could conceivably harm accessibility.
  • An accurate list would be incredibly hard to maintain, because of the complexities described in the previous point. No accurate list has been put forward; the only attempts at making such a list so far have been either vague or woefully inaccurate.
  • Even a vague list would be hard to maintain. We actually had a vague non-normative list in the spec for a while, but ended up removing it from the spec because of the maintenance nightmare that it spawned (the list kept having to be updated because errors kept being found — and that was just with a non-normative vague list).
  • Confusion stemming from the inevitable inaccuracies listed in the previous points will likely lead to implementation mistakes, leading to poor interoperability, which would harm accessibility (since this is an accessibility feature).

In summary: no use cases, maintenance nightmare, might even harm accessibility.

Bug 10462: Merge the table defining strong native semantics and the table listing role and state constraints into a single table

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10462

Providing unclear or ambiguous guidance to authors about how ARIA can be used in HTML5 is likely to negatively impact the correct use of ARIA on the Web. Indeed, failing to provide such information does a disservice to both Web developers, who author ARIA-supporting applications, and to users with disabilities, who rely on those annotations to make use of those applications.

Therefore, it is imperative that the information provided be structured coherently, be compatible with ARIA terminology, and be correct. To this end, it is important that elements with strong native semantics be specified separately from elements with mere defaults and some constraints, and that both sets of requirements be properly introduced with RFC2119 and ARIA terminology. This is what is done in the specification as it stands today.

In summary: keeping the tables separate is key to maintaining the clarity of the specification.

Bug 10448: Allow links to be described as scroll bars, buttons to be described as progress bars, etc

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10448

No use cases have been provided to explain the benefit of allowing links to be described as scroll bars, buttons to be described as progress bars, and so forth, despite repeated requests for use cases.

It has been suggested that occurances of the following need role="button" to be made accessible:

  <a href="#" onclick="action()">...</a>
  <a href="javascript:action()">...</a>

However, both are non-conforming uses of the <a> element in HTML, because they both use the <a> element for a purpose other than representing a hyperlink. They are not syntactically non-conforming because they both have valid use cases in indistinguishable cases: <a href="javascript:"> is needed to expose bookmarklets to users, and onclick="" is needed for a wide variety of interactive purposes even on normal links (e.g. making AJAX applications gracefully degrade). Even a link to href="#" has some use cases, e.g. to link to the current page to provide the user with a draggable URL for bookmarking purposes. There's no reason such links shouldn't be made interactive (e.g. the onclick="" could just trigger a click animation). So we can't catch this particular case with a validator. It's unfortunate, but that's what happens when there are valid use cases.

The role="" attribute gives us the unique opportunity to catch this particular error as a syntax error. This is a good thing, not a problem.

In any case, the above examples should not be exposed to ATs as buttons widgets even if they were valid. They are exposed to users as link widgets, not button widgets, and thus that is the appropriate AT behaviour and the appropriate ARIA role.

ARIA is useful for authors who need to make new widgets that HTML doesn't yet support. Buttons are supported by HTML, and therefore there is no reason for an author to make a link act like a button to ATs.

Making a link act like a button to ATs while leaving it as a link for non-AT users will lead to non-AT users having a confusing experience, since the author will think the link is going to appear as a button to users and may refer to it as such.

What's important to remember is that there are more than two kinds of user agents; there are at least three:

  1. User agents with scripting, CSS, etc, which can be made to render elements (like <a>) as other elements (like <button>).
  2. User agents with ATs, which report the accessibility mapping described with ARIA, defaulting to the default semantics of the elements.
  3. User agents without CSS support or without scripting support, and certainly without ATs, which always use the default semantics of the elements.

Some examples of #3 are the text-based browsers, most search engines, and graphical browsers in which CSS or scripting are disabled.

The only way to keep things consistent amongst all three is to use HTML elements appropriately, and not override their semantics with ARIA.

ARIA is great when you're creating new widgets that aren't in HTML yet: it allows you to create pages that work in #1 and #2, covering the vast majority of users, at the cost of #3, who wouldn't be able to experience the new widget at all anyway. However, when HTML provides the widget you need, as in the case of a button or a link, and #3 already supports that widget and therefore there is no need to fake it. In these cases, ARIA is unsuitable and unnecessary. Validators flag the use of ARIA in these ways, since there is a net benefit to using appropriate elements instead of ARIA in those cases.

See also the section below explaining why use cases are necessary for such features.

Summary: no valid use cases presented; some specific cases would even harm overall accessibility of the Web.

Bug 10449: Allow an H1 element to be described as a spinbutton or checkbox, etc

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10449

No use cases have been provided to explain the benefit of allowing headings to be described as spinbuttons, checkboxes, and so forth, despite repeated requests for use cases.

See also the section below explaining why use cases are necessary for such features.

Summary: no use cases.

Bug 10481: Set the default role of IMG elements to ARIA's "img" value

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10481

Summary:

Bug 10493: Requesting additional prose in the HTML spec stating that certain roles defined in the ARIA spec have restrictions on their use defined in the ARIA spec

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10493

Summary:

Bug 10592: Request regarding the ARIA role of heading elements inside HGROUP elements

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10592

The intent of this bug is assumed to be as described above based on the arguments presented in this issue's other change proposal. The bug itself has an incoherent request, does not state a problem, and was never clarified despite a request by the editor.

HGROUP elements are essentially equivalent to headings that contain multiple "paragraphs" (in the sense defined in the HTML specification). They should be conveyed as such to accessibility tools. This means setting the "heading" role on the HGROUP element, and treating the Hx elements in the HGROUP element the same way as paragraphs are treated normally.

Bug 10594: Move some requirements regarding ARIA attributes into a separate table

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10594

The description of this bug listed above is derived from the other change proposal for this issue; unfortunately neither the bug nor the other change proposal included enough detail to provide an accurate rational description of the request.

We should not make our specifications be confusing, we should not include redundant requirements that are already in other normatively referenced specifications, we should not explicitly state that certain combinations are valid if there's no reason to suspect that they might be invalid.

We should, indeed, include detailed requirements regarding the constraints placed on ARIA attributes in different situations. For example, it is important that the aria-disabled="" attribute be set to "true" on any control that is disabled (not any control that has the disabled="" attribute specified, which is a different matter). It is important that we restrict aria-valuemax="" when set on INPUT elements in the Range state to the maximum value (not necessarily the value given in the max="" attribute). There are a number of such requirements. The specification requires all the ones that make sense.

Bug 10603: ?

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10603

Summary:

Bug 10903: Requesting more introductory text

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=10903

Summary:

Bug 8000: Allow authors to use elements in ways that contradict their semantics

Bug: http://www.w3.org/Bugs/Public/show_bug.cgi?id=8000

Summary:

Why use cases are needed to justify allowing particular roles in particular situations

Note: a working group decision not to add the apparently arbitrary set of roles discussed in the above bugs should not be taken as a working group decision not to add specific roles in specific situations in the future, as use cases are put forward. Should a use case be provided for a particular combination, it should be considered on its own merits and added if appropriate. This change proposal merely argues against a wholesale addition of roles with little to no consideration of specific use cases, especially because a number of the combinations proposed are simply daft.

Details

Change nothing.

Impact

Positive effects

Encourages authors to use HTML as intended, which increases the total accessibility of the Web.

Negative effects

★‬

Conformance Class Changes

None.

Risks

★‬

References

Objections to the other change proposal

If there is objectionable material in the other change proposal that would be inappropriate to list in the above CP, then list it here so that it can be tracked and presented during the poll.

Process objections

  • The discussion about changing the title or adding an introduction section seems out of scope for this issue, since it is already covered by issue 109, which has already gone to poll and is awaiting a chair response.
  • The table added based on the arguments in the basis for addition of "WAI-ARIA and HTML5 Attributes" table section makes numerous changes that were never raised in any bug and that are not justified by any arguments in the change proposal.

Objections to the rationale

Objections to the rationale's introduction

  • The rationale of this CP implies that requiring authors to violate the semantics of elements should be allowed, but this would lead to serious accessibility and data analysis failures, essentially missing the entire point of HTML's design philosophy for the past 20 years, and regressing us substantially to the days of "font" elements, single-pixel GIFs, and layout tables. This would be a disaster for accessibility, a disaster for advocacy, and would lead to such confusion amongst the developer community that we might easily lose a decade of pro-accessibility advocacy progress (historically, developers have reacted quite poorly to dramatic changes in the messaging on such topics).
  • This CP claims that the specification provides tools for authors to violate the semantics of an element in the form of JS and CSS, but does not provide tools in the form of ARIA. However, this is false. The specification provides ARIA tools to violate semantics to the same extent as CSS and JS tools; it makes such violations non-conforming regardless of the technology used (CSS, JS, or ARIA). Therefore this is a false dichotomy: if an author finds it acceptable to violate the specification in one place, it stands to reason that violating the specification elsewhere would be considered no worse, and if an author does not violate the semantics using CSS and/or JS, then there's no need to use ARIA for this use either.
  • ARIA markup happens to be one of the few ways we can programatically verify semantic consistency, and seriously relaxing, or indeed removing, the restrictions on how ARIA can be applied to HTML would cause us to largely, or completely, miss this opportunity to educate users to improve their site's accessibility. Furthermore, the specification details care that validators need to take in the messaging in this area to encourage authors to write better, more accessible markup, rather than having them just drop the ARIA — so the risks detailed in this CP have already been mitigated by the specification's current text.
  • It is important for overall platform consistency that a platform's specifications take a holistic approach, considering all of the features as a whole rather than each one individually. This CP fails to take such an approach, instead treating ARIA markup as a special case to which basic design principles somehow do not apply. For instance, it is implicitly argued in the CP that authors writing HTML without ARIA are able to update their markup, and this is contrasted to the case of an author writing HTML with ARIA where it is explicitly argued that the author cannot update any markup except ARIA markup. However, this is patently absurd: ARIA markup is just as much markup as the rest of HTML, so if one part of the document can be edited, so can the rest. Indeed, in conjunction with the aforementioned advice for validator implementors, it is more likely that authors will correct their non-ARIA markup than the ARIA annotations, since the validator is not expected to even mention ARIA in such situations.
  • The rationale makes a number of false statements or implications. For instance, it refers to ARIA as an "accessibility repair method", which is inaccurate (the word "repair" indeed only appears once in the whole ARIA specification, in the context of images used for mathematics). The ARIA specification's abstract clearly delineates ARIA's role as being for describing "accessible user interface elements" that "can be used to improve the accessibility and interoperability of web content and applications": it is essentially and primarily for annotating "div" and "span" elements that are being used to create custom widgets. Another example of a false statement or implication in this CP is the assertion that the ARIA role taxonomy is designed so that children in that taxonomy can always be used in place of their parents. However, this is trivially disprovable by example: the "radio" role is a child of the "checkbox" role, yet these are not interchangeable native HTML concepts; similarly, the "listitem" role, which requires a "list" parent in the DOM, has as a child role the "treeitem" role, which requires a "group" or "tree" parent, so again these are clearly not interchangeable.

Objections to basis for addition the merging of the tables in the current spec text [sic]

  • The premise that the current text does not define which roles, states, and properties can be used in which situations is flat-out incorrect. That is the bulk of the current section, and it is defined very precisely.
  • No reasoning is provided for merging the list defining the strong native semantics and the list defining restrictions for elements without strong native semantics.
  • Merging these tables results in confused conformance criteria; the subtlety of the current spec's requirement is lost. For example, compare the text in the current spec to the text in the proposed text when it comes to defining the requirements on an input element with a type attribute in the Number state. The current spec text is straightforward. The proposed text in this CP is incoherent. This is, IMHO, a result of this misguided attempt at merging the tables.

Objections to basis for changes to command roles

★‬

Objections to basis for defining h1 to h6 element that does have an hgroup ancestor

The rationale begins by implying that there is ambiguity regarding the default role of elements that the specification does not mention explicitly in the accessibility tool annotations section, but there is no such ambiguity: the default for any element without strong native semantics or implied ARIA semantics is defined by the ARIA specification. The change proposal continues to state that it would be illogical for the specification to require that headings inside HGROUP elements be exposed to UAs in the same way as headings outside HGROUP elements, but this is a straw man argument, since the specification explicitly states that these two cases are not handled the same way, by excluding headings inside HGROUP elements from the normative conformance requirements that apply to headings in general.

The change proposal goes on to state that two adjacent H1 elements with no role should be handled by ARIA user agents in the same way as two adjacent SPAN elements, and says that this is bad. It would indeed be bad, were it true, because it would also imply that ARIA user agents would be unable to convey paragraph breaks! (P elements similarly have no role.) This is naturally quite absurd; indeed, if true even the proposed solution in the change proposal would be broken (consider an HGROUP with three child Hx elements). A number of arguments are predicated on this premise, and are therefore equally faulty.

This section also references the outline algorithm, but this is irrelevant to the discussion as the outline algorithm is orthogonal to the ARIA roles used on elements.

Objections to basis for changes to allowed roles on the a element

This section first argues that Web developers aren't going to be using the specs as a guide of what they can and cannot use, and promptly uses this to argue for changes to the spec. However, this is nonsensical. We should not design the spec's authoring conformance criteria for people who will ignore the spec; they cannot benefit from such changes. The people who will benefit are those who do care about the spec, and we owe it to them to provide them with the most helpful QA tools (such as validators) as we can, primarily by making the spec's conformance criteria as helpful as possible, catching as many likely mistakes and authoring contradictions as possible.

This same section claims that it would be bad if validators complained about ARIA values when detecting a mismatch between native semantics and ARIA values, but this is again an argument against a strawman: the specification in fact specifically suggests that validators not do this.

Objections to basis for addition of "WAI-ARIA and HTML5 Attributes" table

This section argues that the spec leaves this undefined, but this is flat-out incorrect. It is defined very precisely.

Furthermore, the arguments in this section are inconsistent with the arguments in the earlier section which suggested that having one table was clearer. Quite contrary to the earlier arguments that suggested that the spec was to be simplified by merging the two tables, the change proposal actually just changes the split from a coherent separation of elements with strong native semantics and elements with looser constraints, to an apparently incoherent split with attributes listed in one table and then partly repeated in another, data duplicated in multiple cells, etc.

Objections to the proposed text

Overview

  • The proposed text contains internal contradictions. For example, it suggests that the "abbr" element has no default role, but then specifies that the "abbr" element (when defining a command) has, in certain cases, the "menuitem" role; it also simultaneously allows authors to use aria-* attributes only in manners allowed in the HTML spec, allows authors to use aria-* attributes in any manner allowed in the ARIA specs, and requires authors to not use the aria-* attributes in ways that conflict with certain requirements, leaving the exact conformance situation highly unclear.
  • The proposed text either abuses RFC2119 or has bogus conformance statements (it's unclear which). For example, the text explicitly allows "conflicts" to make things "difficult for assistive technology" (presumably mis-use of RFC2119, since "conflicts" are obviously not a defined conformance class); it also in another paragraph allows authors to "need" to do something.
  • The proposed text has redundant conformance requirements, for example it restricts how people may use ARIA features multiple times with subtly different phrasing, without explaining why the requirements are repeated or whether the subtle differences are intended or not. Another example is how it simultaneously has a generic rule regarding state attributes matching equivalent HTML attributes, and has explicit rules for specific attributes. Another example is that it requires support for both the entire ARIA specification and then explicitly requires support for a subset of that specification.
  • It contradicts the ARIA specification. For example, for "abbr" elements it says any aria-* attribute is allowed, but the ARIA spec restricts which attributes are allowed based on the role.
  • It doesn't use the terms defined by ARIA for the purposes required by this section. For example, the term "strong native semantics" is not used. This means the spec breaks the normative definition chain.
  • It allows ARIA attributes that are redundant with HTML native features, despite this having been demonstrated to result in cargo-cult accessibility authoring, which is harmful to accessibility, as discussed in bug 11557 (http://www.w3.org/Bugs/Public/show_bug.cgi?id=11557).

The tables

  • The proposed text supposedly alphabetises the elements to which roles, states, and properties can be applied. However, this is nonsensical:
    • The list is not a list of element types, but a list of conditions that elements can find themselves in, so it makes no sense to alphabetise the list by element name (some of the rows don't have any element name at all!).
    • The list's ordering was the only mechanism for resolving conflicts, by changing the order arbitrarily, this resolution mechanism is lost (leading to some of the problems listed in the overview above).
  • The second table is simply wrong. For example, it refers to the disabled attribute rather than the disabled concept, it requires that draggable be set on elements that are aria-grabbed (a ludicrous requirement), it requires that the aria-checked="" attribute match the default value of the checkedness of a checkbox element, rather than the current state, etc. The entire table is simply full of errors.

Miscellaneous specifics

  • It requires that aria-autocomplete be set in a way that mirrors the autocomplete="" attribute, despite this contradicting ARIA requirements (aria-autocomplete="" is about author-provided autocompletion UI, not UA-provided UI; the UA obviously is responsible for making its UI accessible, not the author!), and despite this being harmful to accessibility even if it didn't contradict ARIA (since it would mean that any UA with unusual autocompletion UI would be inaccessible on pages that followed the rules given in the proposal).