Accessibility Minutes 2009 09 09

From MemberWiki

Jump to: navigation, search



  • Jon Gunderson (University of Illinois)
  • Nathan Jacobiak (ParaSoft)
  • Michael Squillace (IBM)
  • Vio Onut (IBM)
  • Rich Schwerdtfeger (IBM - chair)


Validation Rule Codification Requirements

Validation Rule Codification Requirements

Mike: My Post on Validation Rule Codification

Mike: What I wanted to point out is that I sent out 3 different emails that did not get distributed by the OAA server

Mike: They did show up in the wiki as received emails

Mike: The focus in the wiki is based on the last couple weeks discussions

Mike: I want to talk about rule properties and applicability criteria

Mike: I have incorporated Vio's tagging notion in terms of the context

Mike: There is a piece on the rule logic

Mike: The first thing to do is to look at the wiki and modify, change, etc. the wiki.

Jon: the main thing about the a11y extension. If you are interested in headings and need to get the headings for the page and you run individual heading rules, how do you see the data collection fitting into this.

Mike: I have four possible contexts. What Sandy has I think is rule groups which are executed in the context of particular elements of the same kind

Jon: We create a data structure of the header information. then we run our header rules.

Jon: The code that runs the actual logic that the rule runs agains

Mike: The context would be a certain data collection

Jon: the rule context is right. There would be a document level rule but an intermediate process is required.

Jon: The rule logic needs a pointer to a data structure

Mike: The way the rule logic is executed on a particular rule. There is no reason this could not apply to a collection of elements

Nathan: It appears that you guys are talking about the same thing

Nathan: It is identifying all rules of a particular type and then it is running the test against that set.

Mike: what jon is suggesting is collecting all the rules first or are you collecting the roles and elements first and running against the rules.

Jon: we would need to probably update the data structure first.

Jon: perhaps this is a subset of the rule logic.

Jon: Some rules, such as alt tex missing on an img element, you don't need to collect a lot of information

Mike: ... but you could

Mike: I see your point. If you look at our rules you just take individual elements. each element maps to a rule logic ...

Mike: What you are suggesting is that an engine could pass a data structure representing a list of HTML elements

Jon: For an individual rule if the data structure or create one and then run the rules

Jon: perhaps it is just an implementation detail.

Mike: we would need to distinguish between new and old collections.

Jon: create the data structures and run the rules against them

Mike: it gets more complicated if writing against a data structure logic as the rule is expressed in terms of the data structure

Nathan: I think we need to keep these things separate. It is generally an implementation detail. If you write the rules for a given node you can be flexible in your implementation

Nathan: I think Sandy's data structure is different than just a collection of rules

Nathan: It would be better to express the rule logic in therms of a single node and if want to process of collections they can

Mike: Sandy's rule does this.

Mike: there are individual rules that are executed

Rich: for a given event we should probably scope what it being tested

Mike: We talked about a tabular view of what is tested based on the event

Rich: we can scope what is tested on an event in terms of DOM traversal.

Vio: I think I agree with what is said.

Jon: I think there could be a rule group. This could be an option.

Mike: Sandy's notion of a rule are related to a data collection.

Jon: a rule group is optional

Jon: a rule group is one that adds a common data structure

Mike: So we have individual rules and rule sets

Mike: A rule set embodies a specific spec. or guidelines

Mike: A rules set is based on a particular standard

Nathan: For us the rule set is very general but it may or may not be tied to a standard

Mike: The semantic set is a particluar set of guidelines?

Vio: yes

Nathan: yes, but does not have to be.

Nathan: a collection of rules is fine.

Jon: Hopefully buy next week we can show you our web site

Jon: we have different rule sets based on standards and the question is how to repackage

Jon: our approach is we have these sets of rules and how do we map them to the standards

Rich: supposed to float a draft of the 508 refresh at the end of this month

Mike: we want to reuse the across the different guidelines and reports the user wants met

JonG: Mike: What else do we have here

Mike: I am working on rule set information

JonG: Mike: We need to include severity maybe determined by the rule set, one set might be a violation and another maybe a recommendation

Mike: There is a notion of localization, been talking to Dojo team

Mike: They have a server that uses JSON server to get localization information

Mike: Does Firebug have a localization?

Jon: yes

Nathan: for me, having the rules split out into the file makes sense but I don't want them running on the sever for performance reasons.

Nathan: we need to be able to switch things out based on the locale we are working in

Nathan: I want nothing sitting on the server

Mike: the converse is loading all the languages on the client is a hit to load time.

Vio: I second that. Being able to load based on locale is important. Storing things on a server makes sense.

Nathan: Dojo stores locales on the server based on what is needed.

Rich: So loading locales and caching as needed makes sense.

Mike: for our purposes, how bundles are retrieved and how they are represented is an implementation issue.

Mike: there are 2 sets of things that need to be localized: parts of the rule logic and what errors/warnings are reported

Vio: We might have a flag that indicates something is localizeable.

Mike: like an identifier?

Vio: yes

Vio: Some rules may not be provided for a specific language.

Vio: I am referring to the parameters that go into rules

Vio: they would need to display the right language

Vio: some rules may not need to change the logic.

Vio: I see a decoupling of what is displayed to the user and the rule itself.

Vio: The bottom line is that if there is a rule that needs globalization it should be flagged.

Vio: that will help

Mike: the other option is that you would not need a parameter. The parameter format could have a language indicator.

Mike: I am going to work on the wiki this week.

Mike: I want to include our 10am discussions

Jon: I did some rules and rule logic.

Mike: Next week will have the rules discussion on the Wednesday call next week. Mike to chair next Wednesday.

Reporting Best Practices

Accessibility Reporting Best Practices

Rich: the ARIA subteam addressed the problems we found in the containment model

Rich: Rich will update the JSON file on the ARIA pattern matching

Rich: to look at processing elements whose meaning is determined by host language attributes aka: input type="" ...

ACTION ITEM: Group review Rule Codification requirements for next week

Personal tools