The official React conference, organized by Facebook.

Last year we open sourced React and community adoption blew us away.

React opens a world of new possibilities such as server-side rendering, real-time updates, different rendering targets like svg and canvas.

We need to rethink how we write applications using one-way data flow, immutable data structures, the full power of JavaScript and languages targeting it.

React Conf

Tom Occhino reviews the past and present of React in 2015, and teases where it's going next.

Keynote 1 - Introducing React Native

Christopher Chedeau takes us on a quick tour of the React Native architecture and shows off the developer experience.

Keynote 2 - A Deep Dive into React Native

In this talk, Brenton Simpson talks about how to bring instant-feedback magic into your favorite editor, where the key-bindings are familiar and your favorite transpilers are at your aid. Make changes to your JSX+JS Harmony+Sass-powered app and watch them cascade across every device on your desk in real-time, with no reloading...

Tweak your page in real time, without leaving the comfort of your editor

Lisp programmers have understood the power of the concept of "code as data" for decades. Having a structured representation of your code allows for an untold number of new applications that go far beyond what can be achieved by treating it as a lifeless stream of characters.

Esprima, a parser for javascript pushes your development very far in that direction by allowing you access to an AST (abstract syntax tree) representation of your code, that coupled with the strong conventions and API of React allow for some pretty amazing applications that i'll demonstrate how to implement.

Unlocking the structure of your React applications with the AST

Daniel Schafer and Jing Chen describe the approach Facebook uses to make data fetching simple for developers, even as a project grows to include dozens of developers and the application becomes as complex as Facebook's news feed.

Data fetching for React applications at Facebook

React has a simple way for components to communicate with each other: pass event handlers down through children and events will flow upwards to parent components. This works well for simple components and certain UI events, but it breaks down with large complex apps. The Flux architecture helps with this by defining 'actions' that components can fire and subscribe to, and you write code outside of your components to handle data and dependencies of the actions.

With the advent of 'goroutines' and channels in languages like Go and Clojure, we have a new style of coordinating actions. We have developed a library that allows you to write goroutine-like code on top of generators, called js-csp. I will take a look at how this might be used to handle complex data flow in a React-based app. We will see what parts of Flux and React's event system might be improved, or if it even helps at all!

Communicating with channels

react-router is a powerful routing library built on top of React that helps you add new screens and flows to your application incredibly quickly, all while keeping the URL in sync with what's being displayed on the page. The project benefits from several years of combined experience working with the legendary Ember.js router.

This talk will show how the router makes it easy to implement many common flows including authentication, navigation prompts, and animation. We'll also explore some advanced techniques including server-side rendering and partial application loading.

react-router increases your productivity

Pete Hunt actually doesn't talk about the future of JavaScript layout systems. Instead, this talk is all about full-stack Flux.

Full Stack Flux

We can all appreciate that React apps are easy and awesome. They make great demos that are crushingly good at DOM-manipulations. But as they grow (and they always do), things start to get unwieldy. Big apps — especially ones with long life-spans, huge data sets, or numerous contributors — can suffer serious perf and maintenance inefficiencies.

The Facebook Ads Interfaces team shares what they’ve learned after spending the last year building one of the world’s largest React applications. By being intentional about your app's component hierarchy, separation, and data-passing, you can achieve excellent performance, sustainable even at a massive scale.

Making your app fast with high-performance components

You speak English, but most people don't. Formatting numbers, dates, and pluralizing strings is hard enough to get right in English, let alone internationalizing your web app to support multiple languages. FormatJS with react-intl (open sourced by Yahoo) has your back by providing a declarative way for your React-based app to format data and strings for English and over 150 languages in just 7KB gzipped.

Format data and strings in any language with FormatJS and react-intl

Most of the time, I simply find React to make me more productive with the work-a-day tasks of building a UI in the browser. Other times, when I'm asked by fellow developers or designers if, and how, we could do some kind of crazy sounding thing, I find that React saw it coming.

Lets push the boundaries of what React lets you do with some of the most interesting use-cases I've come across and implemented.

Hype!

The component driven, performance focused approach of React is a perfect complement to the modularity and portability of native HTML Web Components. At first glance, React and Web Components might seem like two radically different solutions to the same problem. But when combined properly they complement each other to create an extremely powerful, expressive framework for developing complex web applications.

The complementarity of React and Web Components

Immutable data unlocks powerful memoization techniques and prohibits accidental coupling via shared mutable state. It's no accident that these are the the same benefits provided by React.

Persistent data structures provide the benefits of immutability while maintaining high performance reads and writes and present a familiar API.

Learn about how persistent immutable data structures work, and techniques for using them in your React applications with Immutable.js, a library of fully persistent immutable data structures.

Immutable Data and React

Netflix has rebuilt our mobile and web UIs. These UIs are hosted in the browser, and we've seen big performance gains thanks to React's virtual DOM. But what if the DOM is just too slow on a given platform?

Netflix uses a canvas-like API to maximize performance on smart TVs and game consoles. Given that React improved performance and simplified the code on our other platforms, we asked ourselves "could React work without the DOM?"

Yes. Not only is it possible to use React without the DOM, React's design is particularly well-suited to working with low-level APIs like Canvas or WebGL. As a matter of fact, React's design is heavily influenced by game-rendering engines. In this talk, you will learn about how we are integrating React with our TV platform, and what design patterns we're using to get a good balance of simplicity and performance.

Beyond the DOM: How Netflix plans to enhance your television experience

Visualizing large-scale data in the browser presents many challenges, including performance of rendering, responding to state changes from user input or data changes, and transforming gigabytes of data into hundreds or thousands of visual elements efficiently. Being able to reason about the effects of state changes, and the performance implications of those effects, becomes even more important at large scale. GraphLab uses React.js extensively to help control the complexity of rendering and enable us to build bigger and better visualizations.

This talk will cover various techniques for rendering, and the pros and cons of each, including: render targets (canvas vs. SVG), client-server application architecture optimized for large data, and integration with other visualization libraries including d3.js. While React.js is a solution for client-side rendering, it must be combined with a whole data pipeline to be effective for rendering larger data than can fit in the browser. By using a stateful server-side and a modified Flux-like architecture, in which XMLHttpRequest communicates with a server-side dispatcher, we can keep transformations close to the raw data and manage client-side application complexity at the same time.

Scalable Data Visualization

Om is a popular ClojureScript binding to React that streamlines integration with persistent data structures. Besides providing basic global state management facilities, it also contains some unique concepts that will be of interest to both users and implementers of React and React-like systems. This talk will explore the design decisions, tradeoffs, and benefits that result from taking a more aggressive stance on application state when pursuing scalable component architecture.

Refracting React

Michael Ridgway (Yahoo!), Spike Brehm (Airbnb), Andres Suarez (SoundCloud), Jing Chen (Facebook), Kyle Davis (Facebook), and Ian Obermiller (Facebook).

Flux Panel

Codecademy recently rebuilt our entire learning environment using React. The learning environment needs to dynamically accommodate various combinations of components (the code editor, browser preview, terminal, and lesson content, for example), leading to changing communication needs. We solved this using meta-programming to create dynamic communication "adapters," allowing us to mix-and-match functionality on the fly. I'll discuss our motivations for doing so, and how this approach has met our needs for flexibility even if it's not the "React way" of doing things.

Codecademy's approach to component communication

Learn how to take advantage of static typing in React with Flow and TypeScript. Flow is a recently released static type checker from Facebook designed to work well with React from the ground up.

TypeScript integration is more difficult and we will cover solutions to common problems such as class system integration and JSX. Both allow you to annotate your React application with types for compile-time checking of invariants and other common issues.

Static typing with Flow and TypeScript

Q&A with the team

2015

React.js Conf is being held in the conference ballroom at the Grant Hyatt hotel, just outside of Union Square in downtown San Francisco, CA.

Facebook engineer Nick Schrock kicks off React.js Conf 2016 by reviewing where React and React Native have been, where they are, and where they are going in the future.

Keynote

In the last few years, React has exploded in popularity, now supporting hundreds of thousands of developers on the web. React also lies at the heart of React Native, which has made it easier than ever to build native mobile apps.

On the React team, we're continually making performance and stability improvements so that React can be a strong foundation. But in our role of helping developers build high-quality products quickly, what new opportunities for React do we see in the future? In this talk, hear about the latest challenges we're facing at Facebook, how React might be able to help solve them in the future, and how we think about developing React.

What Lies Ahead

Plain text is boring. At Facebook, we want to give our users the ability to add mentions, emoticons, hashtags, styles, and embedded media within the content they share. The result is that nearly every input on Facebook requires rich text features.

As UI engineers, we want to provide our product teams with the tools to implement and expand upon these features without pushing them into the contentEditable pit of despair.

This talk will dive into the details of how we used React, ImmutableJS, and yes, contentEditable, to create an editor framework that enables engineers to build and customize rich text composition experiences across Facebook.

Rich Text Editing with React

I'm going to walk you through the wilds of data handling in react. I call it “the wilds” because when you first look at the landscape, it seems to be overflowing with an untamed profusion of different options. The boundaries between these options aren't clear, and it's hard to see why you'd want to pick any one in particular.

When you look closer, you'll see that it's actually easier to navigate than you might think. You just need a good guide.

A Cartoon Guide to the Wilds of Data Handling

The recruiting process employed by major technology companies can often seem like a black box. In a pretty untraditional type of talk for a JavaScript conference, I will dive deep into exactly how the process works at Facebook in order to give you an idea of what to expect and how to prepare if you ever decide to apply for a major technology company.

Demystifying Tech Recruiting

React Native brought the web's enviable debug cycle to mobile, without needing to sacrifice native UI to get there. While this makes for an amazing dev experience, your apps are still ultimately distributed through stores, and therefore, can’t immediately take advantage of the same release agility that is typically associated with web dev. But that doesn't have to be the case!

Whether you are doing distributions within your team, amongst your clients or to your entire consumer base, getting improvements out to users as quickly as possible, and monitoring its impact on usage/satisfaction, can be critical to success. This talk will show how easy it can be to setup an automated build pipeline and release continous app deployments via services like VSTS, HockeyApp and CodePush.

Web-like Release Agility for Native Apps

After a short moment in the 90s, Virtual Reality faded away. Now in 2016, VR is coming back in a big way. Games are leading the charge, but with millions of headsets pouring into the marketplace over the next few years, how can React web and app developers get involved? Can React even handle the screaming-fast performance requirements of VR? Spoiler: it can.

This talk explores these concepts by incrementally building up a mobile VR engine that can be driven not just with JavaScript, but with React. We'll discover how naive approaches fail, and why game engines are built the way they are. Finally, we'll cover some exciting work with WebVR which intends to bring VR to all browsers.

React, Meet Virtual Reality

Flipkart Lite is Progressive Web App built with React, Flux, and Service Workers. This talk will deep dive into how we developed a high-performance mobile web app at scale, by devising a new architecture and taking an unconventional approach to server-side rendering with React.

Hear how React and Flux Stores helped us speed up rendering and how we heavily optimized React Components to achieve 60fps scrolling and interactions. In conjunction with this, learn how we utilized Service Workers to eliminate all network latencies on repeat visits. The result was an immersive and smooth web app that worked seamlessly even on low-end mobile devices and 2g connections.

Building a Progressive Web App

As a belated gift, I’ve created a physical, standalone version of Jeopardy. Featuring React as the project’s interface, an Arduino and a node app running on a Raspberry Pi create an engaging and unique user experience. The presentation highlights React’s potential to respond to input beyond the mouse, including touch, physical buttons, and speech recognition.

How To Use React In A Wedding Gift Without Being A Bad Friend

Gestures, Graphs, and Gaffes

React Native Infinite List Done Right

Oy vey! Email templating with React

React Native: Lessons Learned After Migrating an App from iOS to Android

Gatsby, a React.js Static Site Generator

Reducing Navigation

Nuclide hacks for React Native development

Hotter than Hot Reload - Building Native Mobile Apps with Fuse

Building the Walmart iOS pharmacy with React Native

A New Way to Persist & Query Data in React Native

With React Native, mobile developers are able to increase both their productivity and scope of work. The cross-platform technology is fantastic for teams building for Android and iOS, and developers can take ownership of products & features instead of single-platform implementations.

At Exponent we've extended this idea to include both products and infrastructure. I'll talk a bit about how we apply this to our software development and the benefits and challenges of growing full-stack developers into cross-stack mobile developers who are responsible for Android and iOS.

Team × Technology

gl-react is a universal library for implementing advanced filters and effects on top of images, videos, text or any VDOM Content (such as UI Views) - without having to deal with the imperative and low-level OpenGL and WebGL APIs. Because they are defined as simple React components, complex arrangements can be composed using the VDOM descriptive paradigm.

gl-react hides OpenGL's statefulness and exposes its greatest functional feature: GLSL (an expressive 'functional rendering' language) and its rendering pipeline that runs on the GPU. Effects such as blur, saturation, color rotation and tinting, image composition, noise,... can all be implemented easily. But OpenGL is extremely powerful, unlocking the potential for spectacular effects and UI components: image deformation, localized blur using depth map, normal map effects, and more.

Universal GL Effects for Web and Native

Managing client-side state is pretty easy for TodoMVC, but soon after you move beyond that, your app can quickly get brittle, discouraging re-use and significantly complicating maintenance. I will give an overview of a few of the libraries/frameworks that have appeared recently that try to address this problem, show how each of them looks when used in the React context, and then discuss advantages, disadvantages, common patterns, and what we can learn.

Redux, Re-frame, Relay, Om/next, oh my!

Contributing Vapor

A React Native Restrospective

Buzz: A Distributed, Event-Sourced GraphQL Server

React Native for Web

"Learning" Other Languages Makes You A Better Javascript Developer

Performance and declarative, functional programming are at odds in the minds of many developers. At Netflix, we have an especially challenging performance target to hit. This talk will explore how we managed to take an unflinching stand on a completely declarative React based architecture while maintaining 100ms key-input and 60fps on the 600mhz single-core devices in your living room.

We'll talk about how and why we adhered to principles like no refs, no observation, no mixins or inheritance, immutable hierarchical state, declarative data via Falcor, and top-down-rendering. While some of these principles can actually help performance, we'll share how we mitigated others in order to hit our tough performance targets without compromising.

Performance Without Compromise

GraphQL is quite powerful, but why create our schemas in JS if our backend is in a different language? (Python, PHP/Hack, Ruby, Scala...)

We will do a quick overview of the different GraphQL implementations and focus on Graphene, the main GraphQL Framework for Python that permits setup a GraphQL server and schema in the blink of an eye.

A GraphQL Framework in Non-JS Servers

Applications inevitably get new features over time. While number of features might grow linearly, the increase in coupling across parts of the application is usually exponential and slows down app initialization and degrades performance. We obviously want richer applications, but not necessarily at the cost of performance.

Instead of compromising by choosing one over the other, we've been building abstractions and infrastructure to improve performance, even in the face of increasing complexity. By incrementally loading parts of our application and reducing work required for application initialization, we can significantly simplify and speed up startup. This talk explores some of Facebook's efforts to make initialization faster for large and growing React applications.

Speeding up Startup for Large React Apps

React re-thought best practices for web and native development, but it is limited by the strengths and weaknesses of JavaScript.

Elm takes rethinking best practices even further by asking what a modern language designed for productive development should look like.

Signals and the Elm Architecture help you compose large complex applications out of small, understandable pieces. Elm's powerful type system and emphasis on pure functions and immutable data make refactoring and maintaining large applications faster and easier.

Elm and React share common ideas, and creating a new language helps Elm leverage those ideas in to a better development experience. Learn how Elm can make you a better React developer, and maybe, just maybe, take the plunge in to trying Elm yourself.

Rethinking All Practices: Building Applications in Elm

React Native has seen an impressive adoption since its open-sourcing. Our goal is to make it easier for developers to write awesome native apps and we believe that performance is a prerequisite for a great user experience. We'll go over some of the tools that we use to find and fix performance issues in React Native code, and share some tips and optimisations that you can use to make your own apps faster.

Optimising React Native: Tools and Tips

React isn't yet-another-JavaScript-framework — it's a paradigm shift in the way UIs are engineered. If in ten years we're no longer using React, we'll likely be using something similar. You can already see this in how pre-React libraries like Ember and Angular have pivoted in the wake of React's two big innovations: a declarative component model, and unidirectional data flow.

But it's even more clear when looking at the post-React libraries, which use functional programming concepts to provide powerful architectures for state management. In this talk, I'll show how we can steal some of the best ideas from Om, Cycle, and Elm, and use them in our React applications.

Back to React

Protect your DOM from tampering with React tree obfuscation

Testing Your React Components

The Road to Open Source (wp-calypso)

Weighing the benefits of RxJS in React applications

6 Year olds discovering React Native

2016

React Conf 2017 is being held at the Marriott Santa Clara in California on March 13th and 14th of 2017.

The conference was live-streamed both days, and the talks have been made available to watch. You can catch up with everything you may have missed or watch your favorite talk over and over again.

Keynote Part 1

Keynote Part 2 - Incrementally Adopting React Native at Facebook

Keynote Part 3 - React Performance End to End (React Fiber)

Keynote Part 4 - React Fiber, Create React App, and React Community

A Cartoon Intro to Fiber

Next.js: Universal React Made Easy and Simple

React + ES next = ♥

MobX vs Redux: Comparing the Opposing Paradigms

Type Systems Will Make You a Better JavaScript Developer

Moving Fast with Nuclide and Flow

AWS Lambda + AWS Gateway + React = AWEsome

React to Code

The Road to Styled Components

Building Applications for Studio in Cloud at Netflix

React Native in the "Brown Field"

Moving Beyond Animations User Interactions @ 60 FPS in React Native

You Don't Need a Fancy Framework to Use GraphQL with React

Cross Platform Data Viz with React + React Native

Using React for Anything but Website

React Everything, Render Everywhere

Create React Native App: 5 min. to "Hello, World!"

Goodbye Flatland! An Introduction to ReactVR

Realtime React Apps with GraphQL

Jest Snapshots and Beyond

A Beginner's Guide to Code Splitting Your React App

Web Like Development and Release Agility for React Native

React Storybook: Design, Dev, Doc, Debug Components

Extensible React

Building React Communities Outside of Your Circle

A Prettier Printer (plus bonus clip!)

How to React in the Slow Lane

The Great Convergence with React

Learn Once, Route Anywhere

Taming the Meta Language

Speaker Panel

2017

Two full days of knowledge sharing and community with people who build and LOVE React.

This year’s conference features a mix of panels and talks set against the backdrop of beautiful Lake Las Vegas. In addition to a can’t-miss schedule, we’re organizing off-hour activities providing opportunities for relaxation, adventure, and getting to other React enthusiasts.

React Today and Tomorrow

Learn how Hooks work to make your app better.

90% Cleaner React With Hooks

Building Todo The Game In A Cloud Only Dev Environment

The Path To A Declaratively Animated Future

What's New in Create React App

Components as Units of Work

5 Animations You Should Know and Use

Render Props, PureComponent and Reactivity

Better Living through Git Hooks

GraphQL without GraphQL

Playing With Polyhedra  Creating Beauty from Obsession

Cross platform AR and VR Apps using React Native

Beyond Web Apps  React, JavaScript and WebAssembly

React For Social Change

Concurrent Rendering in React

Learn about the upcoming React Suspense API, and how to use it in your apps.

Moving To React Suspense

SVG Illustrations as React Components

The Missing Abstraction of Charting

Elsa  AI Conversational Agent

Context in React

Building a better Country through Tech

An Effective Code Review

Syncing Component State Across Tabs with Service Workers

Block the Main Thread

React Native's New Architecture

Let React speak your language

Building A Diverse And Inclusive Community

React for Designers with FramerX

2018

Tom talks about how React provides a great Developer Experience by lowering the barrier to entry, and allowing us developers to experiment, be productive and scale our apps, easily. 

He discusses Concurrent mode and Suspense; two technologies that will allows us to improve the User Experience of our apps by making them more responsive and be more native-like. 

Finally, he emphasizes his team’s strong focus on diversity and inclusivity and talks about React’s code of conduct.

Keynote - Part A

Yuzhi takes a look back at what happened since they announced React Hooks in React Conf 2018 and how they became so popular, since they were released with React 16.8. 

Next, she talks about Accessibility and their effort to enable React apps to be more accessible by default, with better focus control and support for more input interfaces. Another area of investigation, is initial render time, better support for Server Side Rendering and the—all new—Progressive Hydration and Selective Hydration. 

Finally, she demonstrates the latest iteration of React Suspense and Concurrent Mode, which are now available as experimental features!

Keynote - Part B

Frank talks about the evolution of Facebook as a website, and the challenges that they faced as they try to extend and enhance it.

Frank talks about the evolution of Facebook as a website, and the challenges that they faced as they try to extend and enhance it. They recently rebuild the website from scratch(!), using React, GraphQL, and Relay. 

Their goal was to create a modern design system, improve accessibility, and achieve faster page loads and seamless interactions. 

In the process, they created their own CSS-In-JS library, whose features Franks presents, as he goes through the new frontend architecture.

Building the new Facebook with React and Relay - Part A

How does app performance look at scale? Ashley dives deep into the details of how they rebuilt Facebook.com and achieved super-fast rendering times and network transfers.

See the technologies and strategies powering the new Facebook.com. Their approach to CSS-in-JS, data-driven dependencies, phased code downloading, and more.

Building the new Facebook with React and Relay - Part B

Food waste is one of the biggest environmental and social challenges facing the planet. OLIO helps people connect and share surplus food. And it's built in React Native!

How our team is using React Native to save the world

A compelling, real-world, case study of how TypeScript and GraphQL helped overcome issues with legacy code, iterate faster, and provide more value to users.

As a startup that integrates with larger, often older enterprises, we have to integrate with  a number of RESTful services (against our will). This technical talk will outline how we are able to bring type-soundness, autocompletion, and powerful developer tooling to our internal workflows using hooks and TypeScript.

Using hooks and codegen

It is important to understand the abstractions that we use (watch “Requisite React”). This is a deep dive into React’s architecture. Watch Sophie build a simple version of React DOM.

There's a little-known npm package named react-reconciler that lets you build your own React renderer. React DOM and React Native themselves are built on top of it. And with it, you can build your own. In this talk, we'll build a simple version of React DOM. With any luck, you'll walk away with a better understanding of React.

Building a Custom React Renderer

Tree shaking (dead code elimination) can be an invaluable feature in modern build tools to keep bundle sizes slim. Unfortunately, it's can also be easy to ""break"" and overlook with a single import star (import *). Imagine this slips in and is overlooked for months, only to later realize it adds over 4 megabytes. But now, its implicitly relied upon in hundreds of places.

This is a story about creating a custom codemod transform to update hundreds of implicit usages to be explicit imports to ""fix"" tree shaking and remove nearly 97% of the unused code.

Codemod-ing away 4MB of JavaScript

This talk will cover how I accidentally discovered time travel in git, how to change the auto-detected language of your GitHub repositories and other Git related hacks to make working with Git and GitHub more delightful (or maybe just make your commit history less embarrassing git hooks).

Git is hard, but time travel in git is easy

Using codegen sorcery I will show you how to scaffold an entire type safe api layer, client and server, by only defining your graphql schema.

Automagic TypeScript Codegen for GraphQL

Not long ago, most companies looked down on front-end engineering. They thought the real engineers programmed the server in Java, while the script kiddies played around with it's wannabe little brother, JavaScript. 

But, in the last several years, React and its ilk have proven that sophisticated approaches to immutability and asynchrony allow for unprecedented scale and complexity in the front-end. 

Now, the tables have turned, and back-end frameworks are starting to wake up to the benefits of asynchronous processes and event sourcing patterns, following the trail that React has blazed.

Why React is eating the World

From around the world, voices sounded out in a multitude of languages: is React Translated Yet? With the efforts of hundreds of contributors, I can finally say: ¡Sí! Sim! はい 

Over the course of a month, I helped the React team kick off translations of reactjs.org into 40 languages. Join me for a behind-the-scenes look at what it takes to get the docs for a massively popular library translated. 

We'll talk about GitHub rate limits, managing a global community, amateur bot-building and more!

Is React Translated Yet?

When building a design system, many implicit choices are made in a component’s architecture that can end up crushing the dreams of a productivity-boosting frontend utility and turning a shared component library into a vessel for friction, factions, and forking. 

Join us as we take you through the journey of Airbnb’s experience creating an effective, widely-adopted design system and the decisions and trade-offs that were made to get there.

Building (And Re-Building) the Airbnb Design System

Learn how to get started with accessibility, with common tools, patterns, and starter-tips.

Accessibility standards are often first on the chopping block in the face of deadlines. We've all been on projects where we write that dreaded TODO comment leaving an accessibility audit for later. Let's unpack why that is and start changing it! 

We'll look at common tools, patterns and starter-tips that can help us shed light on accessibility in a new, less daunting way. 

In this talk we'll discuss how to get started with accessibility—the metaphorical salad and power walking of a11y that can prepare us to run an accessibility marathon, if you will.