From the schedule session:
How can WordPress adopt an accessible-first approach, and what would this mean for project development and decision-making? This discussion will center on accessibilityAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) considerations in developing WordPress software and current friction points, and explore possible solutions and practices to incorporate.
Perspectives needed: Current and interested accessibility advocates, people interested in or currently involved in release cycles.
Facilitator: Joe Simpson, Jr (@joesimpsonjr)
Notetaker 1: Weston Ruter (@westonruter)
Notetaker 2: Daniel Bachhuber (@danielbachhuber)
Raw Notes
- What does accessibility-first development mean? Move into design as an outshoot from how the feature works. Instead of being design-first approach which is the current process. It is helter-skelter as some people go code-first and others go design-first. We don’t have a system for the process. We should have a well-defined process.
- What would be the biggest resistance to going to a new process? For people who think visually, very hard to reverse the thinking to think about functionality first.
- What would a document look like for a11yAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility)-first development? We have examples of visual-first approach, e.g. mocks for admin redesign.
- No specific examples can be pointed to, but what an a11y-first approach should first consider the order that things happen in. Then we consider what it looks like.
- Visual design documents don’t consider what something is, but rather just what it looks like.
- User-centric approach seems like what is in mind, what the pathways are. User flows, with the context of what something is, whether button or link.
- A lot of people are set in their ways for how they do things.
- The most important thing is to get to good feedback as quick as possible. Visual designs allow for feedback to be obtained for the 90% of users who are visual. Paper-to-code without high-fidelity is another approach. Usable high quality feedback is needed as early as possible.
- Copy editor would write copy with the person they are working with, and they’d wait until the visual designs are put together. But it needs to be early, same asia11y
- Uncertainty about the workflow between the accessibility team and design team.
- Coding school teaches not to worry about high fidelity until they’ve done something really rudimentary. The school also has them number out what they’re doing (“accessibility right from the start”). DOM order is captured.
- Onus is too often put on the a11y team to do things the right way.
- Checklist is being put together on learn for how to make accessible content. People don’t know where to start, how to use a screen reader, etc. Documentation is needed for how to do a11y.
- What can really tire people out is age-old problems that come up over and over again. What we can’t seem to ever move past is designers want something one way. There are many places where there are no save/cancel buttons, for example renaming blocks in the list view, or link dialog. Designers think that esc/enter key is all that is needed to save or cancel.
- Think about the sequential process beyond just mouse clicks.
- As a developer without a11y expertise and not needing a11y-friendly interfaces (except for when keyboard shortcuts are absent), what is needed is good entry points to learning a11y, internalizing the mindset for a11y. Basecamp defined Shape Up process, using breadboards: defining what something needs to do instead of what it looks like. High fidelity mocks too often get put put first before functionality is defined. Accessibility is not rigorous part of the development process.
- Perennial problem with GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ is code gets merged quickly which aren’t then fixed when merged to WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. Things are getting in the back door. People aren’t following up. Acceptance criteria aren’t being met. Prototypes are getting shipped.
- Basecamp has excellent accessibility. So their methodology may help.
- In admin redesign, would it be helpful to have design overview page with patterns for how things can be done properly.
- Plugins can also follow such guidelines. WordPress is designed to be extended by plugins. Whatever process happens needs to be thinking about the ecosystem, not just the core.
- Requirements at the pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party level can help push things forward.
- One plugin author reports that they’re receiving more and more emails about whether their plugin is accessible.
- Why is “helping train people” a common theme?
- It takes observing someone use your project for it to hit home on how inaccessible it is. Review each other’s projects.
- WP sandbox could offer a way to “earlier on” accessibility testing.
- Some trouble could be happening when “developers are literally just trying something”. Maybe we need an accessibility review once it’s in Gutenberg behind a feature flag. This scenario can happen when there are no existing designs.
- The design handbook is woefully out of date.
- A lot of education needs to be done, like in Learn WordPress. In a sandbox environment, help users to replicate a11y experiences to teach what the issues are. This is similar to having glasses that simulate color blindness.
- Specific instructions with PRs and testing.
- Learn WordPress doesn’t have anything substantial for a11y, other than SEO heading copy writing. We need checklists and tools for doing bare minimum.
- Local accessibility center ran workshops. Most people don’t know they have a screen reader on their computer where they can test out accessibility.
- Checklists can make reviews much easier: “what should I review for?” Start small to not overwhelm. Checklist is great as it can evolve over time.
- Developers need something preemptive over checklist. Human interface guidelines are needed, such as whenever there is a modal. Instead, right now it is very disorienting and inconsistent. There should be a resource that outlines the accessibility solution for a given design need.
- A checklist can be very valuable but they’re also limiting, as they can quickly become overwhelming. There needs to be minimal checklist before it goes for a11y review.
- Checklist is important for new developers to be aware of as a baseline.
- Admin redesign is exciting and it’s a potential case study for how we can make sure it is accessible from the start.
- Developers either lack the skills or incentives. There have been a11y experts who have left WP because of pushback they got on feedback. Designers have to realize they can’t always use the designs they want. We need to do more to support a11y as a developer community.
- Setting goals or some quantification of accessibility can make it easier to ensure we’re progressing in the ways we want to.
- How can we communicate out for everyone to improve the process?
- One way is over a11y hangouts; recorded so knowledge can be shared easily, linking to segment that has key information.
- Learn WordPress course
- Watch someone use the experience with a11y tools
- There are also a11y roundup posts.
- The conversations are very nuanced. One challenge is that there are sometimes conflicting needs.
- There should be deep-dives into things like how to properly design a modal for accessibility.
- With admin redesign, we can have reusable a11y-by-default components that plugins can reuse.
- If we have an accessible components library, it’s not a silver bullet. Developers can still find ways to use them without accessibility. With prototyping, the command palette started out as a prototype and it almost shipped without getting any a11y considerations. Reactive measures were needed.
- Suggestion to create much more detailed issues in the repository. “If you already know which component to use, include that in the issue”. Avoids the guesswork of which component to use.
- There are dead-end prototypes that don’t need a11y reviews as it would be a waste of time; we need to flag things that aren’t going anywhere. How do we best use a11y resources? There are few people and we need to not overload them. We need to figure out when to surface things.
- We have a tendency to add accessibility later, think of it as a review, etc. It’s really a development mindset set that needs to shift. Think of accessibility along the lines of security, performance, and other code-planning aspects.
- With a11y there is a base level, similar to i18n: a given function is used. WP needs to get to baseline of being usable for everyone, but that doesn’t mean it is accessible by everyone. We want it to be a great experience for everyone if using assistive technologies.
- Limitations of checklists and automated testing is they get you to good micro accessibility, but they can’t capture or address any macro accessibility issues (how to navigate around the canvas). It’s totally possible to create terrible accessibility following WCAGWCAG WCAG is an acronym for Web Content Accessibility Guidelines. These guidelines are helping make sure the internet is accessible to all people no matter how they would need to access the internet (screen-reader, keyboard only, etc) https://www.w3.org/TR/WCAG21/.. Think about scope of macro accessibility, where the whole experience is good.
- We also have to consider the devices that people are using. What about people who are mobile only? Most of the world doesn’t have good Internet access. Most of the world doesn’t have good laptops. Minimize what we’re adding on top of WordPress.
- Four actions:
- Issue on Learn WordPress is filed
- Design handbook to be updated for a11y
- Working sessions around modals at a11y hangouts
- WP admin redesign post to be commented on to add a11y feedback
- Two actions:
- Learn has various pathways. It has one for i18n but it is slacking one for a11y.
- Collaborate on a11y checklist.
- We need documentation for how to use a11y tools, like screen readers. Subject matter experts needed. Tutorials.
- What are the top 3 topics need to be on Learn for developers?
- Introduction to keyboard testing
- Accessible naming
- Fundamentals of HTMLHTML HTML is an acronym for Hyper Text Markup Language. It is a markup language that is used in the development of web pages and websites. structure and semantics
- Screen reader testing? Hard for non-expert.
- Admin redesign project is key opportunity to make a11y headway, high impact.
- Redesign will need reaching out to PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. http://php.net/manual/en/intro-whatis.php. developers with something like Fields APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways..
- Videos on dotorg or Tavern often lack any voiceover and no captions.
- Admin redesign post was useless to someone who is not sighted, or even for someone who is an older adult.
- It’s a lot of extra work to write a script to make videos accessible.
- What’s new in Gutenberg posts need to have voiceovers.
- If you can just talk through the process you’te taking when recording a video, and the audio is transcribed, it could also serve as a caption.
- Should WP 6.5 be entirely focused on a11y?
- Bug-focused releases have been attempted many times. It just doesn’t work. It has to be done along with exciting features.
- Make a list across all Make teams for what they can respectively can do to improve a11y.
- Do WordPress releases have a11y leads?
- Not since 5.9.
- Release squad members include a11y role.
- Needs a volunteer.
- We need code contributors.
- We need someone who can help creating accessible content for release notes.