<commit_before># Motivation

A common requirement when working with Redux is managing state that is persisted
to a server. Because communicating with remote servers requires sending messages
over a network, reading and writing this state does not happen instantly. The
requests take time, and they may sometimes fail.

This has an impact on the user interfaces that we build. One tenet of good user
interface design is to always provide feedback to the users of the application.
When it comes to network requests, users need to know which requests are in
flight, which have failed, and which have succeeded.

When using Redux, this means writing reducers that manage this state as requests
are made. For some projects, manually writing the reducers may work well. For
larger projects, you might run into problems if you write these reducers by
hand.

For one, the data representing these requests may be stored in different ways
for different parts of the store. This inconsistency in your data will
propagate to the view layer. Code bases that are not consistent are more
difficult to maintain and to work with. Ensuring that information about requests
is stored consistently will increase developer productivity.

Additionally, tracking all of this data for every request requires writing a lot
of reducer code. You may omit writing some of that code to save on time, which
has two consequences: it makes that piece of state inconsistent with others, and
it also gives you less information to work with when building your interface.
The user experience of the application may suffer as a result.

resourceful-redux is intended to solve these problems. It provides a system of
organizing information about data in a consistent way. It also comes with
reducers that keep track of as much information as possible about every request
made to remote servers, so that you don't have to.

Use resourceful-redux to have more time to build great interfaces, rather than
writing boilerplate reducer code.
<commit_msg>Further tweaks to the motivation section<commit_after># Motivation

Many applications work with state that is persisted to a server. Because
communicating with remote servers requires sending messages over a network,
reading and writing this state does not happen instantly. The requests take
time, and they may sometimes fail.

It's a developer's job to provide feedback to users about network
requests. When using Redux, this requires writing reducers that change the state
based on the status of these requests. For projects with many resources, you can
run into problems when you write these reducers by hand.

You might store request data in a different way for different resources. This
inconsistency will propagate to your view layer. Code bases that are
not consistent are more difficult to maintain.

Additionally, tracking all of this data for every request requires writing a lot
of reducer code. You may omit writing some of that code to save on time. This
contributes to consistency, and also gives you, as the developer, less
data to use to provide feedback to your users.

resourceful-redux is intended to solve these problems. It provides a system of
organizing information about request state in a consistent way. It also comes
with reducers that keep track of as much information as possible about every
request made to remote servers, so that you don't have to.

Use resourceful-redux to have more time to build great interfaces, rather than
writing boilerplate reducer code.

{'fraction_non_alphanumeric': 0.021974885844748857, 'fraction_numerical': 0.0, 'mean_word_length': 4.689935064935065, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 3, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '5876614', 'n_tokens_mistral': 787, 'n_tokens_neox': 752, 'n_words': 562}