First portion of Kara's comments

Author: kapunahelewong

public/docs/ts/latest/guide/reactive-forms.jade

@@ -1,7 +1,7 @@
 include ../_util-fns
 
 :marked
-  _Reactive forms_ is an Angular technology for creating data entry forms in a _reactive_ style.
+  _Reactive forms_ is an Angular technology for creating forms in a _reactive_ style.
   This guide explains reactive forms as you follow the steps to build a "Hero Detail Editor" form.
 
 a#toc
@@ -46,42 +46,54 @@ a#intro
   UI-oriented _form model_ that retains the states 
   and values of the HTML controls on screen.
 
-  With _reactive_ forms, you create a tree of Angular form controls in code, and 
-  bind them to HTML widgets in the component template, using techniques described in this guide.
+  With _reactive_ forms, you create a tree of Angular form control objects
+  in the component class and bind them to native form control elements in the 
+  component template, using techniques described in this guide.
 
-  The component class is responsible for all data flowing between the component and the screen.
-  It has immediate access to both the data model and the form control structure. 
-  It pushes data model values into the form controls and 
-  pulls user-changed values back out of the form controls.
-  The component can _observe_ changes in form control state and _react_ to those changes.
+  With reactive forms, you create and manipulate form control objects directly in the 
+  component class. As the component class has immediate access to both the data 
+  model and the form control structure, you can push data model values into 
+  the form controls and pull user-changed values back out. The component can 
+  observe changes in form control state and react to those changes.
 
-  In keeping with the reactive paradigm, the component should preserve the immutability of the _data model_,
+  One advantage of working with the form control objects directly is that 
+  value and validity updates are always synchronous. This contrasts with 
+  template-driven forms, which must update asynchronously because they 
+  delegate operations to a directive running in the template.
+
+  In keeping with the reactive paradigm, the component  
+  preserves the immutability of the _data model_,
   treating it as a pure source of original values.
   Rather than update the data model directly, 
   the component extracts user changes and forwards them to an external component or service,
   which does something with them (such as saving them) 
   and returns a new _data model_ to the component that reflects the updated model state.
 
+  Using reactive form directives does not require you to follow all reactive priniciples,
+  but it does facilitate the reactive programming approach should you choose to use it.
+
   ### _Template-driven_ forms
 
   _Template-driven_ forms, introduced in the [Template guide](forms.html), take a completely different approach.
 
   You place HTML form controls (such as `<input>` and `<select>`) in the component template and 
-  bind them to _data model_ properties in the component, using the `[(ngModel)]` two-way data binding directive.
-  
-  You don't create Angular form controls. Angular infers them from the data bindings.
-  You don't push and pull data values. Angular handles that for you with `[(ngModel)]`.
+  bind them to _data model_ properties in the component, using directives 
+  like `[(ngModel)]`.
+
+  You don't create Angular form control objects. Angular directives 
+  create them for you, using the information in your data bindings. 
+  You don't push and pull data values. Angular handles that for you with `ngModel`.
   Angular updates the mutable _data model_ with user changes as they happen.
 
   Both data binding and the mutable _data model_ are contrary to reactive principles.
   In fact, the `ngModel` directive is only available in the `FormsModule`, not in the `ReactiveFormsModule`.
 
-  These diffences don't make _template-driven forms_ wrong and _reactive forms_ right.
-  These are different architectural paradigms, with their own strengths and weaknesses,
+  These differences reflect two architectural paradigms, 
+  with their own strengths and weaknesses,
   and you are free to choose between them.
 
   The balance of this _reactive forms_ guide assumes the _reactive_ paradigm and 
-  concentrates exclusively on the reactive forms technology and techniques. For 
+  concentrates exclusively on the reactive forms technique. For 
   information on _template driven forms_, see the [Template Guide](forms.html).
 
   You'll learn about reactive forms by building one from scratch,
@@ -144,30 +156,14 @@ a#create-component
 +makeExample('reactive-forms/ts/app/hero-detail.component.ts', 'reactive-comp-imports','app/hero-detail.component.ts')(format=".")
 
 :marked
-  Here’s a summary description of the imported symbols, whose meaning and use
-  will become clear over the course of this guide:
-
-  - `Component`: the Angular decorator that describes the component in metadata.
-  - `EventEmitter`: a class that emits events that are handled by a parent component.
-  - `Input`: identifies a component's public input properties for data binding by a parent component.
-  - `Output`: identifies a component's public output properties for data binding by a parent component.  
-  - `OnChanges`: a component lifecycle hook that Angular calls when input values change.
-  - `FormArray`: an array of `FormControls`.
-  - `FormBuilder`: a builder of `FormControls`, `FormGroups`, and `FormArrays`.
-  - `FormControl`: a representation of an HTML form control.
-  - `FormGroup`: a group of `FormControls`, `FormArrays`, and other `FormGroups`.
-  - `Address` and `Hero` are application model classes.
-  - `states`: U.S. states (test data). 
-
   Now enter the `@Component` decorator that specifies the `HeroDetailComponent` metadata:
 
 +makeExample('reactive-forms/ts/app/hero-detail.component.ts', 'reactive-comp-metadata','app/hero-detail.component.ts (excerpt)')(format=".")
 
 :marked
   The `moduleId: module.id` lets you use 
-  [component-relative paths](./cookbook/component-relative-paths.html) in file URLs. 
-  The `selector` tells Angular the name of the element tag that renders this form. 
-  The `templateUrl` is the location of the HTML template that displays the form.
+  [component-relative paths](./cookbook/component-relative-paths.html) in file URLs 
+  such as when specifying the `templateUrl`.
 
   Next, create an exported `HeroDetailComponent` class with a `FormControl`.