Considerations for making a tree view component accessible - Related to scaling, workloads, practices, how, run

Considerations for making a tree view component accessible

Tree views are a core part of the GitHub experience. You’ve encountered one if you’ve ever navigated through a repository’s file structure or reviewed a pull request.

On GitHub, a tree view is the list of folders and the files they contain. It is analogous to the directory structure your operating system uses as a way of organizing things.

Tree views are notoriously difficult to implement in an accessible way. This post is a deep dive into some of the major considerations that went into how we made GitHub’s tree view component accessible. We hope that it can be used as a reference and help others.

It’s critical to have components with complex interaction requirements map to something people are already familiar with using. This allows for responsiveness to the keypresses they will try to navigate and take action on our tree view instances.

We elected to adopt Windows File Explorer’s tree view implementation, given the prominence of Windows’ usage for desktop screen reader consumers.

Navigating and taking actions on items in Windows’ tree view using NVDA and JAWS helped us get a superior understanding of how things worked, including factors such as focus management, keyboard shortcuts, and expected assistive technology announcements.

The ARIA Authoring Practices Guide (APG) is a bit of an odd artifact. It looks official but is no longer recognized by the W3C as a formal document.

This is to say that the APG can serve as a helpful high-level resource for things to consider for your overall approach, but its suggestions for code necessitate deeper scrutiny.

At its core, a tree view is a list of lists. Because of this, we used ul and li elements for parent and child nodes:

.github/ source/ test/ .gitignore [website].

There are a few reasons for doing this, but the main considerations are:

advanced assurance that a meaningful accessibility tree is generated,.

Lessening the work we need for future maintenance, and consequential re-verification that our updates continue to work properly, and.

more effective guaranteed interoperability between different browsers, apps, and other technologies.

NOTE: GitHub currently does not virtualize its file trees. We would need to revisit this architectural decision if this ever changes.

enhanced broad assistive technology support.

The more complicated an interactive pattern is, the greater the risk that there are bugs or gaps with assistive technology support.

Given the size of the audience GitHub serves, it’s key that we consider more than just majority share assistive technology considerations.

We found that utilizing semantic HTML elements also performed more effective for some less-common assistive technologies. This was especially relevant with some lower-power devices, like an entry-level Android smartphone from 2021.

Semantic HTML elements also map to native operating system UI patterns, meaning that Forced Color Mode’s heuristics will recognize them without any additional effort. This is helpful for people who rely on the mode to see screen content.

The heuristic mapping behavior does not occur if we used semantically neutral div or span elements, and would have to be manually recreated and maintained.

A composite widget allows a component that contains multiple interactive elements to only require one tab stop unless someone chooses to interact with it further.

Consider a file tree for a repository that contains 500+ files in 20+ directories. Without a composite widget treatment, someone may have to press Tab far too many times to bypass the file tree component and get what they need.

Like using a composite widget, landmark regions help some people quickly and efficiently navigate through larger overall sections of the page. Because of this, we wrapped the entire file tree in a nav landmark element.

This does not mean every tree view component should be a landmark, however! We made this decision for the file tree because it is frequently interacted with as a way to navigate through a repository’s content.

A roving tabindex is a technique that uses tabindex="-1" applied to each element in a series, and then updates the tabindex value to use 0 instead in response to user keyboard input. This allows someone to traverse the series of elements, as focus “roves” to follow their keypresses.

The roving tabindex approach performed more effective than utilizing aria-activedescendant , which had issues with VoiceOver on macOS and iOS.

We use a considered set of ARIA declarations to build off our semantic foundation.

Note that while we intentionally started with semantic HTML, there are certain ARIA declarations that are needed. The use of ARIA here is necessary and intentional, as it expands the capabilities of HTML to describe something that HTML alone cannot describe—a tree view construct.

Our overall approach follows what the APG hints at, in that we use the following:

role="tree" is placed on the parent ul element, to communicate that it is a tree view construct.

is placed on the parent element, to communicate that it is a tree view construct. role="treeitem" is placed on the child li elements, to communicate that they are tree view nodes.

is placed on the child elements, to communicate that they are tree view nodes. role="group" is declared on child ul elements, to communicate that they contain branch and leaf nodes.

is declared on child elements, to communicate that they contain branch and leaf nodes. aria-expanded is declared on directories, with a value of true to communicate that the branch node is in an opened state and a value of false to communicate that it is in a collapsed state instead.

is declared on directories, with a value of to communicate that the branch node is in an opened state and a value of to communicate that it is in a collapsed state instead. aria-selected is used to indicate if branch or leaf nodes have been chosen by user navigation, and can therefore have user actions applied to them.

aria-hidden="true" is applied to SVG icons (folders, files, etc.) to ensure its content is not revealed.

is applied to SVG icons (folders, files, etc.) to ensure its content is not introduced. aria-current="true" is placed on the selected node to improved support when a node is deep linked to via URL.

NOTE: We use “branch node” and “leaf node” as broad terms that can apply to all tree view components we use on GitHub. For the file tree, branch nodes would correspond to directories and subdirectories, and leaf nodes would correspond to files.

The following behaviors are what people will try when operating a tree view construct, so we support them:

Tab : Places focus on the entire tree view component, then moves focus to the next focusable item on the view.

: Places focus on the entire tree view component, then moves focus to the next focusable item on the view. Enter : If a branch node is selected: Displays the directory’s contents. If a leaf node is selected: Displays the leaf node’s contents.

: Down : Moves selection to the next node that can be selected without opening or closing a node.

: Moves selection to the next node that can be selected without opening or closing a node. Up : Moves selection to the previous node that can be selected without opening or closing a node.

: Moves selection to the previous node that can be selected without opening or closing a node. Right : If a branch node is selected and in a collapsed state: Expands the selected collapsed branch node and does not move selection. If a branch node is selected and in an expanded state: Moves selection to the directory’s first child node.

: Left : If a branch node is selected and in an expanded state: Collapses the selected collapsed directory node and does not move selection. If a branch node is selected and in a collapsed state: Moves selection to the node’s parent directory. If a leaf node is selected: Moves selection to the leaf node’s parent directory.

: End : Moves selection to the last node that can be selected.

: Moves selection to the last node that can be selected. Home : Moves selection to the first node that can be selected.

We also support typeahead selection, as we are modeling Windows File Explorer’s tree view behaviors. Here, we move selection to the node closest to the currently selected node whose name matches what the user types.

Nodes on tree view constructs are tree items, not links. Because of this, tree view nodes do not support the behaviors you get with using an anchor element, such as opening its URL in a new tab or window.

Tree views on GitHub can take time to retrieve their content, and we may not always know how much content a branch node contains.

Live region announcements are tricky to get right, but integral to creating an equivalent experience. We use the following announcements:

If there is a known amount of nodes that load, we enumerate the incoming content with an announcement that reads, “Loading {x} items.”.

If there is an unknown number of nodes that load, we instead use a more generic announcement of, “Loading…”.

If there are no nodes that load we use an announcement message that reads, “{branch node name} is empty.”.

Additionally, we manage focus for loading content:

If focus is placed on a placeholder loading node when the content loads in: Move focus from the placeholder node to the first child node in the branch node.

If focus is on a placeholder loading node but the branch node does not contain content: Move focus back to the branch node. Additionally, we remove the branch node’s aria-expanded declaration.

Circumstances can conspire to interfere with a tree view component’s intended behavior. Examples of this could be a branch node failing to retrieve content or a partial system outage.

In these scenarios, the tree view component will use a straightforward dialog component to communicate the error.

As previously touched on, complicated interaction patterns run the risk of compatibility issues. Because of this, it’s essential to test your efforts with actual assistive technology to ensure it actually works.

We made the following adjustments to provide more effective assistive technology support:

Screen readers can findings on the depth of a nested list item. For example, a li element placed inside of a ul element nested three levels deep can announce itself as such.

We found that we needed to explicitly declare the level on each li element to recreate this behavior for a tree view. For our example, we’d also need to set aria-level="3" on the li element.

This fix addressed multiple forms of assistive technology we tested with.

Explicitly set the node’s accessible name on the li element.

A node’s accessible name is typically set by the text string placed inside the li element:

However, we found that VoiceOver on macOS and iOS did not support this. This may be because of the relative complexity of each node’s inner DOM structure.

We used aria-labelledby to get around this problem, with a value that pointed to the id set on the text portion of each node:

the node’s accessible name is unveiled when focus is placed on the li element,.

element, and that the announcement matches what is shown visually.

There’s a couple areas we’re prototyping and iterating on to more effective serve our customers:

Browsers apply a lot of behaviors to anchor elements, such as the ability to copy the URL.

Tree views constructs were designed assuming a user will only ever navigate to a node and activate it.

GitHub has use cases that require actions other than activating the node, and we’re exploring how to accomplish that. This is exciting, as it represents an opportunity to evolve the tree view construct on the web.

An accessible tree view is a complicated component to make, and it requires a lot of effort and testing to get right. However, this work helps to ensure that everyone can use a core part of GitHub, regardless of device, circumstance, or ability.

We hope that highlighting the considerations that went into our work can help you on your accessibility journey.

Share your experience: We’d love to hear from you if you’ve run into issues using our tree view component with assistive technology. This feedback is invaluable to helping us continue to make GitHub more accessible.

Cloud infrastructure starts simple—but as teams scale, Terraform scripts become harder to maintain. A monolithic setu......

Have you ever considered yourself a detective at heart? Cybersecurity researchers are digital detectives, uncovering vulnerabilities before malicious ......

You know about Baseline, right? And you may have heard that the Chrome team made a web component for it.

How to Run an Effective Sprint Review

Having attended Sprint Review meetings for over 15 years, I’ve seen both highly productive sessions that drive alignment and progress — and ones that feel like a frustrating waste of time.

When done right, Sprint Reviews keep teams on course, provide critical stakeholder feedback, and reinforce trust in the Scrum process. However, when handled poorly, they lead to disengagement, confusion, and missed opportunities for improvement.

In this guide, I’ll walk you through practical steps to run a Sprint Review that not only showcases progress but also fosters collaboration, drives meaningful discussions, and keeps your project moving in the right direction.

The Sprint Review is usually the first meeting on the last day of the Sprint. In my experience, It Is held first, and then the scrum team conducts its Sprint Retrospective.

The purpose of the Sprint Reviews is for the engineers to show the work they’ve completed within the sprint to any stakeholders. The stakeholders can then give feedback on that work, and everyone can discuss whether the sprint goals were hit and whether the work is on target.

Sure, you can tell the stakeholders you’ve completed some work, but demonstrating the work is always easier to understand and builds more confidence that the project is on track.

Anyone interested in the project should be invited.

While the Scrum team is the core attendee, others, such as Sales, Senior Management, additional Scrum teams, and Project Managers, can also benefit from attending.

If someone can provide insights or gain value from the meeting, they should attend it.

To ensure a well-run session, presenters must be well-prepared.

Live demonstrations can be unpredictable, so I always recommend that presenters record the demos of their work beforehand and show the videos instead.

Also, the person running the meeting should organize demos on related topics. Grouping demos minimizes context switching and streamlines the meeting’s flow.

Engineers present completed work to the Scrum team and stakeholders during the Sprint Review. After each presentation, participants can ask questions and share feedback.

Questions can focus on technical details or how the work aligns with business objectives.

Though everyone is encouraged to contribute, the main presenters are typically engineers. This allows for focused discussions, with input from Product, QA, and Business Analysts as needed.

Consider a six-engineer team working on different components:

Daniel: Implements account lockout after five failed login attempts, requiring a password reset.

Stephen: Introduces a “Forgot Password” functionality, emailing reset links.

Lara: Enhances reporting to log “User Exceeded Max Login Attempts” events.

Elisa: Optimizes the reporting dashboard for faster load times.

Owain: Enables combined event tracking for streamlined data insights.

Grouping similar topics keeps the discussion cohesive. For instance, Login Page updates are presented first, followed by reporting improvements, and lastly, the two performance-related stories are shown.

Stakeholders may ask clarifying questions, like why five login attempts were chosen before an account locks. There may or may not be a decision regarding whether this is the correct number within the meeting. Typically, you would organize a follow-up after the meeting to make a decision.

The reason for gathering so many people from different teams and departments is not only to show progress but also to get feedback from a wide variety of people, all of whom have different experiences.

For example, someone in the room may ask why we use the traditional Username and Password paradigm and not the “magic email link” login method.

These types of questions and comments make the Sprint Review so helpful. You are getting feedback early enough in the projection allows you to make changes before it’s too late.

Best Practices for an Effective Sprint Review.

Rather than relying on slides, showcase functional deliverables. A working feature demo is far more engaging than screenshots.

Encourage active participation by inviting questions and discussions. Document stakeholder feedback and determine whether adjustments should be incorporated into the backlog.

A well-organized Sprint Review should follow this format:

Overview of sprint goals; Demos of completed work; Feedback and discussion of next steps.

Avoid overly technical discussions that derail the meeting. If deeper analysis is required, schedule a follow-up session.

Based on review feedback, immediately upgrade the backlog. If enhancements are requested, document them promptly and then send them to the Sprint Review attendees to ensure you’ve captured them correctly.

Keep people interested, keep meetings focused, and hold meetings quickly​​. If the session runs long, your scrum team may be too large. Consider splitting it into smaller, more agile teams.

Sprint Reviews should last no more than an hour to ninety minutes. Sprints Reviews are large meetings involving many people; therefore, they are expensive. Keep them short, or risk management complaining about them.

An effective Sprint Review provides visibility into completed work, ensures alignment among stakeholders, and collects valuable input that allows for quick change (the primary purpose of Agile).

To maximize the value of your Sprint Review, focus on clear communication, structured presentations, and active engagement from stakeholders. Encourage open discussions, document feedback promptly, and translate insights into actionable backlog items. By consistently refining your Sprint Review process, you’ll foster stronger collaboration, maintain stakeholder confidence, and keep your team aligned toward delivering meaningful outcomes.

A well-run Sprint Review isn’t just a meeting — it’s your team’s opportunity to showcase progress, spark innovation, and steer the project toward success.

You’ve read the memos and listened to the talks.

Most of the time Copilot is just reading my mind and i only need to press TAB a couple of times.

BUT there are other times where it is like.

React, introduced by Facebook (now Meta) in 2013, forever changed how developers build user interfaces. At that time, the front-end ecosystem already ......

Best Practices for Scaling Kafka-Based Workloads

Apache Kafka is known for its ability to process a huge quantity of events in real time. However, to handle millions of events, we need to follow certain best practices while implementing both Kafka producer services and consumer services.

Before start using Kafka in your projects, let's understand when to use Kafka:

Real-time analytics . Kafka is especially really helpful in building real-time data processing pipelines, where data needs to be processed as soon as it arrives. It allows you to stream data to analytics engines like Kafka streams, Apache Spark, or Flink for immediate analytics/insights and stream or batch processing.

Decoupling applications . While acting as a central message hub, it can decouple different parts of an application, enabling independent development and scaling of services and encouraging the responsible segregation principle.

Data integration across systems. When integrating distributed systems, Kafka can efficiently transfer data between different applications across teams/projects, acting as a reliable data broker.

Key Differences from Other Queuing Systems.

Below are the differences of Apache Kafka from systems like ActiveMQ, ZeroMQ, and VerneMQ:

Kafka stores events in a distributed log, allowing the ability to replay data anytime and data persistence even in case of system/node failures, unlike some traditional message queues, which might rely on in-memory storage like Redis.

Data is partitioned across brokers/topics, enabling parallel processing of large data streams and high throughput. This helps consumer threads to connect to individual partitioning, promoting horizontal scalability.

User activity consumed by ML teams to detect suspicious activity.

Recommendation team to build recommendations.

By configuring [website] and [website] , you can increase the throughput of your Kafka producer. [website] is the maximum size of the batch in bytes. Kafka will attempt to batch it before sending it to producers.

[website] determines the maximum time in milliseconds that the producer will wait for additional messages to be added to the batch for processing.

Configuring batch size and [website] settings significantly helps the performance of the system by controlling how much data is accumulated before sending it to processing systems, allowing for superior throughput and reduced latencies when dealing with large volumes of data. It can also introduce slight delays depending on the chosen values. Especially, a large batch size with a correct [website] can optimize data transfer efficiencies.

Another way to increase throughput is to enable compression through the [website] configuration. The producer can compress data with gzip , snappy , or lz4 before sending it to the brokers. For large data volumes, this configuration helps compression overhead with network efficiency. It also saves bandwidth and increases the throughput of the system. Additionally, by setting the appropriate serializer and key serializer, we can ensure data is serialized in a format compatible with your consumers.

To ensure the reliability of the Kafka producer, you should enable retries and idempotency. By configuring retries , the producer can automatically resend any batch of data that does not get ack by the broker within a specified number of tries.

This configuration controls the level of acknowledgment required from the broker before considering a message sent successfully. By choosing the right acks level, you can control your application's reliability. Below are the accepted values for this configuration.

0 – fastest, but no guarantee of message delivery.

– fastest, but no guarantee of message delivery. 1 – message is acknowledged once it's written to the leader broker, providing basic reliability.

– message is acknowledged once it's written to the leader broker, providing basic reliability. all – message is considered delivered only when all replicas have acknowledged it, ensuring high durability.

you should start tracking metrics like message send rate, batch size, and error rates to identify performance bottlenecks. Regularly check and adjust producer settings based on the feature/data modifications or updates.

Every Kafka consumer should belong to a consumer group; a consumer group can contain one or more consumers. By creating more consumers in the group, you can scale up to read from all partitions, allowing you to process a huge volume of data. The [website] configuration helps identify the consumer group to which the consumer belongs, allowing for load balancing across multiple consumers consuming from the same topic. The best practice is to use meaningful group IDs to easily identify consumer groups within your application.

You can control when your application commits offsets, which can help to avoid data loss. There are two ways to commit offsets: automatic and manual. For high-throughput applications, you should consider manual commit for enhanced control.

[website] reset – defines what to do when a consumer starts consuming a topic with no committed offsets ([website], a new topic or a consumer joining a group for the first time). Options include earliest (read from the beginning), latest (read from the end), or none (throw an error). Choose "earliest" for most use cases to avoid missing data when a new consumer joins a group. Controls how a consumer starts consuming data, ensuring proper behavior when a consumer is restarted or added to a group.

[website] – helps configure to automatically commit offsets periodically. G enerally, we set value to false for most production scenarios where we don't need high reliability and manually commit offsets within your application logic to ensure exact-once processing. Provides control to manage offset commits, allowing for more control over data processing.

[website] – i nterval in milliseconds at which offsets are automatically committed if [website] is set to true . Modify based on your application's processing time to avoid data loss due to unexpected failure.

This configuration helps control the number of records retrieved in each request, configure the [website] and [website] . Increasing this value can help improve the throughput of your applications while reducing CPU usage and reducing the number of calls made to brokers.

[website] – the m inimum number of bytes to fetch from a broker in a single poll request. Set a small value to avoid unnecessary network calls, but not too small to avoid excessive polling. It helps optimize the network efficiency by preventing small, frequent requests.

[website] – the maximum number of bytes to pull from a broker in a single polling request. Adjust based on available memory to stop overloading the consumer workers. This reduces the amount of data retrieved in a single poll, avoiding memory issues.

[website] – the maximum time to wait for a poll request to return data before timing out. Set a good timeout to avoid consumer hangs/lags if data is not available. It helps prevent consumers from getting stuck waiting for messages for too long. (Sometimes, k8s pods may restart if the liveness probes are impacted).

This is the strategy used to assign partitions ( partition.assignment.strategy ) to consumers within a group ([website], range , roundrobin ). Use range for most scenarios to evenly distribute partitions across consumers. This enables balanced load distribution among consumers in a group.

Here are some key considerations before using Kafka:

Complexity . Implementing Kafka requires a deeper understanding of distributed systems concepts like partitioning and offset management due to its advanced elements and configurations.

Monitoring and management . Implementing monitoring and Kafka cluster management is key to ensure high availability and performance.

Security. Implementing robust security practices to protect sensitive data flowing through the Kafka topics is also critical.

Implementing these best practices can help you scale your Kafka-based applications to handle millions/billions of events. However, it's essential to remember that the optimal configuration can vary based on the specific requirements of your application.

As a best-selling author, I invite you to explore my books on Amazon. Don't forget to follow me on Medium and show your support. Thank you! Your suppo......

This week's Java roundup for January 27th, 2025, capabilities news highlighting: the GA release of Java Operator SDK [website]; the January 2025 release of Open......

Keycloak is a powerful authentication and authorization solution that provides plenty of useful capabilities, such as roles and subgroups, an advanced pas......