Change Proposal for ISSUE-129
Don't allow people to use ARIA to write inaccessible documents.
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.
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" , 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
- 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).
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
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 part, this is done by keeping the tables separate.
Summary: keeping the tables separate is key to maintaining the clarity of the specification.
Bug 10603: Confusion arising from an earlier attempt at resolving the aforementioned bugs
An earlier attempt at resolving bug 10444 (mentioned above) created substantial confusion in the specification. For this reason, we should not include the information requested in bug 10444. Since the issue raised in bug 10444 was fixed, and since no complaints were made in the bug regarding the fix, it is unclear what would need to change to further satisfy the request made in this bug.
Summary: Issue seems to already be resolved.
The two bugs are more or less duplicates of each other.
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:
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:
- User agents with scripting, CSS, etc, which can be made to render elements (like <a>) as other elements (like <button>).
- User agents with ATs, which report the accessibility mapping described with ARIA, defaulting to the default semantics of the elements.
- 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.
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.
In the absence of concrete use cases, and given the preposterousness of using an element whose semantic is "heading" to mark up a checkbox or scrollbar, of all things, it would do authors a disservice not to flag such questionable 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
For most images, role=img is unsuitable, because the IMG element's main purpose (from the point of view of an AT user) is not to convey an image, but to convey text. For example, an image as part of a link conveys information about the link. An image of a company logo conveys the name of a company. An image of social networking site conveys the name of that site. Informally, if one browses the Web one will quickly find that most images are either presentational (alt=""), logos, text in buttons or links, or icons. Very few are actually interesting from the point of view of conveying actual graphical information. Even on pages where one would think there were interesting images, they are in the minority — for example, the Flickr page for a photograph has on the order of 20 images only one of which is really an image from the AT user's perspective.
Using role=img for an IMG element is therefore likely to lead to a relatively poor user experience. Rather than getting on with the job of letting the user interact with the page, an AT user would be constantly reminded that the page is full of images, something which a non-AT user would never think of.
It is sometimes argued that the reason role=img is supposedly necessary is that without it, image-specific user interface commands, e.g. to view the image in a separate tab, or to obtain the image's dimensions or URL, would be unavailable. However, such behaviour would be nonsensical. A user may still wish to interact with a presentational image (with role=presentational, not role=img), and a non-IMG element (e.g. DIV) with role=img would not get image-specific user interface commands (those commands would be meaningless). The two issues are thus obviously orthogonal. role=img only controls how the element is presented by the AT by default; it should not prevent users from interacting with images as images if they so desire.
Summary: Defaulting IMG elements to role=img when most IMG elements do not convey images would lead to a poor user experience and cannot be necessary to allow users to interact with images as images.
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
The suggested text, as well as the text that it was intended to clarify, is merely redundantly repeating ARIA requirements, which are best left to the ARIA specification. Having redundant text courts mistakes (as the original text presumably demonstrated, assuming the proposed correction was itself correct), which then results in reader confusion and, in the worst case, interoperability inconsistencies as different implementations interpret each implied instruction independently.
Summary: Suggested clarification is out of scope for the specification.
Bug 10592: Request regarding the ARIA role of heading elements inside HGROUP elements
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.
Summary: What the spec requires is the appropriate set of roles for this situation.
Bug 10594: Move some requirements regarding ARIA attributes into a separate table
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.
Summary: What the spec says is already what is appropriate for these requirements.
Bug 10903: Requesting more introductory text
This is out of scope for this issue since it is already a part of ISSUE-109, which has already been taken to poll.
Why use cases are needed to justify allowing particular roles in particular situations
Using a role in a particular situation is either reasonable, on unreasonable. For example, labeling list items (LI elements) as role="treeitem" is reasonable, since one can use nested lists to create trees without violating any semantics (a tree can in fact be described as a structure of nested lists). On the other hand, labeling a list item as a role="heading" is unreasonable, because there is no need for it and thus occurrences of such markup are highly likely to be indicative of either underlying semantic misuse (which can lead to usability problems in non-AT non-CSS/JS UAs, processing problems in markup analysis tools like search engines, maintenance difficulties, etc), or of unintentional markup errors (for which authors would benefit from validators and other QA tools flagging the problem).
Thus, to craft the conformance criteria for HTML's use of ARIA, we have to figure out what features fall into the "reasonable" camp and which fall into the "unreasonable" camp. (This is supported by ARIA itself, which provides hooks for markup languages to use to indicate exactly this categorisation — that's the whole point of having "strong native semantics", which is one of the main things the accessibility annotations section defines.) To do this in a consistent way, the main tool we have at our disposal is the consideration of use cases. This is why use cases are needed to justify allowing particular roles in particular situations. Thankfully, this is not an especially burdensome bar; it is relatively trivial to describe use cases that exist. Furthermore, it is easy to loosen the rules as use cases are discovered over time; there is no rush to allow as much as possible as soon as possible.
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.
- Keeps the specification clear.
- Encourages authors to use HTML as intended, which increases the total accessibility of the Web.
- Allows authors to check both HTML validity (with an HTML validator), catching errors such as using a BUTTON element where an A element would be more appropriate and more accessible; and ARIA validity (with an ARIA validator), catching errors where ARIA attributes are used incorrectly (regardless of the validity of the underlying markup, and indeed regardless of its vocabulary — HTML, SVG, MathML, or even a custom language).
None. Specifically, two classes of changes are at stake here: editorial changes to the section on accessibility annotations, and normative changes to the integration with ARIA. This change proposal explains why the proposed editorial changes would be regression. Changes to the ARIA integration are not ruled out by this change proposal should appropriate use cases be brought forward, and there is no harm in applying prudence to this process.
Conformance Class Changes
Including the ARIA section at all might encourage authors to create more custom widgets. Given the limitations of ARIA and the limitations of most Web authors in wielding tools such as ARIA, it is likely that this would lead to an overall reduction in the accessibility of the Web. Since very few features expressible in ARIA are still not expressible in native HTML, it might be better for the platform as a whole to simply provide the widgets that authors need rather than having them create them manually with bolt-on accessibility provided courtesy of ARIA attributes.