 
   One common operation is to load data in response to a user interaction. Interestingly, the query that you might
   have used in the initial load use case might have included UI queries for data you didn't want to fetch yet. So, we want
-  to note that the initial load use-case supports eliding part of the query. For example, you can load an item without,
-  say, comments. Later, when the user wants to see comments you can supply a button that can load the comments on demand.
-
-  This is directly supported by `load-field`, which derives the query to send to the server from the component itself!
+  to note that the initial load use-case supports eliding part of the query. For example, you can for example load an item without
+  comments. Later, when the user wants to see comments you can supply a button that can load the comments on demand. The earlier
+  use case on startup demonstrated this technique.
+
+  The `load-field` function, which derives the query to send to the server from the component itself, can be used to trigger the 
+  load of the subsequent data:
 
   ```
   (load-field this :comments)


  ### Load vs. Load Data vs. Load Field

  All of these function families are calls to the built-in `untangled/load` mutation behind the scenes, so requests made by these functions
  go through the same networking layer and have the same customizations through their named parameters (see the doc strings
  in the [data-fetch namespace](https://github.com/untangled-web/untangled-client/blob/master/src/untangled/client/data_fetch.cljs)).
  The only difference is in how the query is specified. `load` requires a top-level keyword and a component, `load-data`
  must be passed a complete query, and `load-field` uses the passed-in component and a field name to create its query.

  `load-field` is really just a helper for a common use-case: loading a field of some specific thing on the screen. It
   focuses the component's query to the specified field, associates the component's ident with the query,
  and asks the UI to re-render all components with the calling component's ident after the load is complete. Since `load-field`
  requires a component to build the query sent to the server it cannot be used with the reconciler. If you want to load data
  from your server when the app initially loads, you must use `load-data` with the reconciler passed to the
  `:started-callback` function when creating a new untangled client application.

  #### Use case - Initial load

  In Untangled, initial load is an explicit step. You simply put calls to `load` or `load-data` in your app start callback.

      - Non-opaque reasoning
      - No need to write parser logic to figure out if you want to do remote reads
  - The costs are:
      - The UI is aware of what is remote, and what is local (in stock Om, the UI *can be* completely unconcerned
        about remoting, though in practice you want to trigger this kind of thing from the UI an expose it as
        some kind of mutation.)

  In practice, we've found that the idea that something involves a server is pretty clear-cut even at the UI layer,
  so the ability to completely abstract it away really isn't that necessary pragmatically, and the cost of writing
  the behind-the-scenes logic related making a parser trigger remote reads is somewhat high.

  #### A bit More About How it Works
