       user.update(age: 26)
       #=> User[name: "Hello", age: 26]
 
-  All the calls above are happening at runtime. It gives Elixir
-  records a lot of flexibility at the cost of performance since
+  All the calls above happen at runtime. It gives Elixir
+  records flexibility at the cost of performance since
   there is more work happening at runtime.
 
-  To sum it up, `defrecordp` should be used when you don't want
+  To sum up, `defrecordp` should be used when you don't want
   to expose the record information while `defrecord` should be used
   whenever you want to share a record within your code or with other
   libraries or whenever you need to dynamically set or update fields.
 
-  You can learn more about it on `Kernel.defrecord/2` docs. Now
-  let's discuss the usefulness of using records with protocols.
+  You can learn more about records in the `Kernel.defrecord/2` docs. Now
+  let's discuss the usefulness of combining records with protocols.
 
   ## Protocols
 

  values by name:

      # Create a new record
      user = user()

      # And now change its age to 26
      user(user, age: 26)

  Since `user` is a macro, all the work happens at compilation time.
  This means all the operations, like changing the age above, works
  as a simple tuple operation at runtime:

      # This update operation...
      user(user, age: 26)

      # Literally translates to this one:
      set_elem(user, 2, 26)

  For this reason, the following operation is not allowed as all
  values need to be explicit:

      new_values = [age: 26]
      user(user, new_values)

  As the name says, `defrecordp` is useful when you don't want to
  expose the record definition. The `user` macro used above, for


  In the example above, `defrecordp` is going to generate a set of
  macros named `user` that allows us to create, update and match
  on a record. Our record is going to have two fields, a `name` with
  default value of "José" and `age` of 25.

  Let's see some examples:

