At , we recently made the leap to for our React state management needs. Before using Recoil, Kitemaker used a simple state management solution built upon . We built Kitemaker to be super fast, responding to every user interaction instantly. However, in organizations with lots of data, we sometimes had a difficult time achieving this due to unnecessary re-renders. Kitemaker has a sync engine under the hood that is constantly syncing data in the background between clients. With this always triggered a top-down re-render and we had to rely on memoization to keep things snappy. Kitemaker Recoil.js useReducer() useReducer() We reached for Recoil to help us minimize re-renders in order to keep Kitemaker fast and responsive regardless of what changes are flowing in via background syncs. We chose it over other competing frameworks like MobX because we liked the explicitness of its API and its similarity to Redux which we were already familiar with. Additionally, the fact that the Meta team designed Recoil for the purpose of building performant UIs with large datasets was a major draw. While we’ve been very happy with the decision and we have seen the benefits we’d hoped for, it did come with some gotchas. A little terminology Let’s get everyone on the same page about Recoil’s terminology first: An is a piece of state stored by Recoil. In Kitemaker, we have items for things like work items, labels, users, comments and more atom A is a derived piece of state. It fetches data from atoms (or other selectors), and transforms them in some way. An example of a selector in Kitemaker would be “fetch all of the comments for this particular work item” selector Write fine-grained selectors In order to make your UI perform well with Recoil, it’s important to understand what actually causes renders. Fortunately, it’s pretty simple - if a selector returns a simple value (string, number, boolean), it triggers a re-render whenever that value changes. If a selector returns an object or an array, Recoil re-renders if the returned value is not referentially equal (i.e. ) to the previous value. === What this means in practice is that you want to write selectors that are quite fine-grained. Stick to simple values, avoiding arrays and objects where possible. Take for example the board view in Kitemaker: Let’s say we want to render the title of a card. We could write a selector that returns the entire atom, but if we did this, every single time that atom changed, we’d cause a re-render of the component. We don’t care about the properties of that atom, we just want the title, so we should write a selector like this: all const workItemTitleSelector = selectorFamily({
  key: 'WorkItemTitle',
  get:
    (workItemId: string | undefined | null) =>
      ({ get }) => {
        return get(workItems(workItemId)?.title;
    },
});

// only fetch what we need!
function WorkItemCard({ workItemId }: { workItemId: string }) {
  const workItemTitle = useRecoilValue(workItemTitleSelector(workItemId));
  return (
    <div>
      {workItemTitle}
    </div>
  );
} Now we’re only fetching the title, so only changes to the title will cause a re-render. Win! Dealing with selectors that return objects and arrays Before we said you should try to return as specific a value as possible from your selectors. But what if we have no choice but to return an object or an array from your selectors? For example, in Kitemaker, we often return a sorted list of IDs that we’ll then render in some sort of a list or board. Unfortunately, Recoil just doesn’t handle these cases very well out of the box. We that allowed us to provide our own equality checks for selectors (or selector families). We have a custom selector family implementation that looks like this: found a solution function equalSelectorFamily<T, P extends SerializableParam>(
  options: EqualSelectorFamilyOptions<T, P>
) {
  const inner = selectorFamily<T, P>({
    key: `${options.key}_inner`,
    get: options.get,
  });

  const priorValues: Map<P, T | undefined> = new Map();

  return selectorFamily<T, P>({
    ...options,
    key: options.key,
    get:
      (param: P) =>
      ({ get }) => {
        const latest = get(inner(param));
        const prior = priorValues.get(param);
        if (prior != null && options.equals(latest, prior)) {
          return prior;
        }
        priorValues.set(param, latest);
        return latest;
      },
  });
} The idea is that if two consecutive executions of the selector result in the same value (as defined by the supplied equality operator), the selector just returns the old value, thus preserving referential equality and preventing a re-render. To use it we do something like this: const filteredWorkItemsByStatusSelector = equalSelectorFamily({
  key: 'FiltereWorkItemsByStatus',
  get:
    ({ spaceId, filterString }: { spaceId: string | undefined; filterString: string }) =>
    ({ get }) => {
      const itemIds: string[] = getFilteredWorkItemsSomehow(get, spaceId, filterString);
      return itemIds:
    },
  equals: _.isEqual,
}); Now if the two arrays returned are equal (as per lodash’s isEqual function in this case), we don’t re-render. Hopefully Recoil will solve this for us in the future in a proper way 🤞There’s a promising but parameter on selector that should allow selectors to use value equality instead of referential equality. However, in our initial testing, this still failed to prevent re-renders from selectors that returned objects or arrays. yet undocumented equality cachePolicy Leverage transactions In Kitemaker, we have some complex operations. For example, adding a backlog to a space in Kitemaker creates a new board object, adds various columns to it, and more. In order to minimize re-renders (and to prevent users from seeing weird intermediate states) we want to apply all of our changes in a single atomic operation. Fortunately, Recoil has an awesome solution for this - . transactions In the case of Kitemaker, we always use transactions inside of a function (though there is a hook as well: useRecoilCallback() useRecoilTransaction_UNSTABLE() interface BulkItemCreator {
  create(items: Array<{ id: string; name: string }>): void;
}

export function useBulkCreateExample() {
  return useRecoilCallback(
    ({ transact_UNSTABLE }) =>
      (callback: (creator: BulkItemCreator) => void) => {
        transact_UNSTABLE(({ set, get }) => {
          callback({
            create(items) {
              // all of these set() calls happen in one atomic operation
              for (const item of items) {
                set(itemAtomFamily(item.id), item);
              }
              // you can use get() here, but only for atoms, not selectors
            },
          });
        });
      }
  );
}

// Simple example of using a transaction
function SomeComponent() {
  const bulkCreate = useBulkCreateExample();
  const handleClick = React.useCallback(() => {
    bulkCreate((creator) => {
      creator.create([
        { id: '123', name: 'Bob' },
        { id: '234', name: 'Susan' },
      ]);
    });
  }, []);

  return <button onClick={handleClick}>Create</button>;
} These transactions are considered an unstable feature (thus the naming) but in our experience, they work great. There are some gotchas, however - the main one being that you may not access any selectors inside of a transaction. This is because selectors are not updated as the individual operations of a transaction are applied to the recoil state, so the data in the selectors would be stale. This hasn’t been a big problem for us as the data fetching needs of this transaction code tends to be very simple. Also, there’s a performance overhead with creating the snapshot inside of a transaction, so keep this in mind. Watch your atom count As the number of atoms in Recoil increases, there’s some performance impact. There is a lot of bookkeeping for dependency checking, etc. inside of Recoil that does not scale linearly. Additionally, whenever you need to grab a snapshot, it gets slower based on how large your set of atoms is. As a result, you need to think a bit about how you bucket your data into atoms. Does every single object need to be a separate atom? Or maybe if you always access a list of items together as a unit, you can shove the entire list into an atom. Then you can still write nice specific selectors on top (possibly using the equality tricks above) to fetch just the data you need to minimize re-renders. Of course, selectors are not free and in some cases, changes to data may cause selectors to be frequently reevaluated. That means it’s a bit of a balancing act between specific selectors and managing your atom count. A rule of thumb is to group up atoms that are generally rendered together and which change relatively infrequently. Wrapping it up To summarize, using Recoil we were able to eliminate unnecessary renders in React. Instead of top-down, full-screen re-renders with a bunch of memoization, we now have a very minimal number of re-renders whenever our data changes. However, Recoil isn’t magic. It really pays to take the time to understand what things cause re-renders and other performance issues so you can avoid those landmines in your implementation. Want to learn more about Recoil or how we built Kitemaker? Always happy to chat on or . Twitter email This article was first published here.

BUNCH

Fetch

Instantly

kitemaker

Super

Twitter

Too Long; Didn't Read

In your car, at home, or at work — Bosch technology shapes many areas of life.

The Lessons We Learned From Moving to Recoil.js

Too Long; Didn't Read

Companies Mentioned

Kevin Simons

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

The Lessons We Learned From Moving to Recoil.js

Too Long; Didn't Read

Companies Mentioned

Kevin Simons

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

RELATED STORIES