 
   ## Om Next Components can use Stock React components
 
-  The first major strength is that Om Next integrates with stock React components. So, if you already
-  understand React you already have a head start. If you know nothing of React, you should eventually
+  The first major strength is that Om Next (and therefore Untangled) integrates with stock React components. So, if you already
+  understand React then you already have a head start. If you know nothing of React, you should eventually
   read more about it. For now, we'll cover everything you need to know.
 
   ## The Rendering Model

                     ...}}
  ```

  A table is just an entry in the database that, by convention, includes a namespace and name to indicate the kind of
  thing in the table and how it is indexed. The value of the table is just a map whose keys are the IDs, and values
  are the entries.

  The general app state is held in a top-level atom. So, updating any object in the database generally takes the
  form:

  ```
  (swap! state update-in [:table/key id] operation)
  ```

  or in our example case:

  ```
  (swap! state update-in [:counter/by-id 1] increment-counter)
  ```

  NOTE: You still need to know *where* to put this code.

  ## Mutations as Abstract Transactions

  In Untangled, you don't do model twiddling on the UI. There is a clear separation of concerns for several good
  reasons:

  - It generally pays not to mix your low-level logic with UI.
  - The concept of an abstract mutation can isolate the UI from networking, server interactions, and async thinking.
  - Abstract mutations give nice auditing and comprehension on both client and server.

  The main UI entry point to affecting a change is the `om/transact!` function. This function lets you submit
  an abstract sequence of modifications that you'd like to make, and isolates the UI author from the details of
  implementing that model/remote behavior.

  The concrete artifacts you'll see in Untangled code are the invocation of the `transact!`, and the implementation
  of the operations listed in the transaction:

  - The render refresh story is mostly automatic, and where it isn't, it
  is completely abstracted from the UI structure to ease developer reasoning.

  If you're coming from Om Next, you should know that Untangled is *not* a competing project. Untangled is a set of
  thin libraries that
  provide default implementations of all of the artifacts you'd normally have to write to make a full-stack
   Om Next application. In many cases Untangled is required to 'make a call' about how to do something.
   When it does, our documentation tries to discuss the relative merits and costs.

  The name 'Untangled' is *not* meant to be a commentary on Om Next, but instead on the general state of web
  development circa 2016. Om Next and Untangled are two layers of a solution that makes things
