docs: Edits to remove jargon (angular#42928)

PR Close angular#42928

Author: TeriGlover

aio/content/guide/dynamic-form.md

@@ -3,15 +3,15 @@
 Many forms, such as questionaires, can be very similar to one another in format and intent.
 To make it faster and easier to generate different versions of such a form,
 you can create a *dynamic form template* based on metadata that describes the business object model.
-You can then use the template to generate new forms automatically, according to changes in the data model.
+Then, use the template to generate new forms automatically, according to changes in the data model.
 
 The technique is particularly useful when you have a type of form whose content must
 change frequently to meet rapidly changing business and regulatory requirements.
 A typical use case is a questionaire. You might need to get input from users in different contexts.
 The format and style of the forms a user sees should remain constant, while the actual questions you need to ask vary with the context.
 
 In this tutorial you will build a dynamic form that presents a basic questionaire.
-You will build an online application for heroes seeking employment.
+You build an online application for heroes seeking employment.
 The agency is constantly tinkering with the application process, but by using the dynamic form
 you can create the new forms on the fly without changing the application code.
 
@@ -81,14 +81,14 @@ The following `QuestionBase` is a base class for a set of controls that can repr
 
 From this base, the example derives two new classes, `TextboxQuestion` and `DropdownQuestion`,
 that represent different control types.
-When you create the form template in the next step, you will instantiate these specific question types in order to render the appropriate controls dynamically.
+When you create the form template in the next step, you instantiate these specific question types in order to render the appropriate controls dynamically.
 
-* The `TextboxQuestion` control type presents a question and allows users to enter input.
+* The `TextboxQuestion` control type presents a question and lets users enter input.
 
    <code-example path="dynamic-form/src/app/question-textbox.ts" header="src/app/question-textbox.ts"></code-example>
 
-   The `TextboxQuestion` control type will be represented in a form template using an `<input>` element.
-   The `type` attribute of the element will be defined based on the `type` field specified in the `options` argument (for example `text`, `email`, `url`).
+   The `TextboxQuestion` control type is represented in a form template using an `<input>` element.
+   The `type` attribute of the element is defined based on the `type` field specified in the `options` argument (for example `text`, `email`, `url`).
 
 * The `DropdownQuestion` control presents a list of choices in a select box.
 
@@ -105,7 +105,7 @@ The following `QuestionControlService` collects a set of `FormGroup` instances t
 
 ## Compose dynamic form contents
 
-The dynamic form itself will be represented by a container component, which you will add in a later step.
+The dynamic form itself is represented by a container component, which you add in a later step.
 Each question is represented in the form component's template by an `<app-question>` tag, which matches an instance of `DynamicFormQuestionComponent`.
 
 The `DynamicFormQuestionComponent` is responsible for rendering the details of an individual question based on values in the data-bound question object.
@@ -134,7 +134,7 @@ The switch uses directives with the [`formControlName`](api/forms/FormControlNam
 ### Supply data
 
 Another service is needed to supply a specific set of questions from which to build an individual form.
-For this exercise you will create the `QuestionService` to supply this array of questions from the hard-coded sample data.
+For this exercise you create the `QuestionService` to supply this array of questions from the hard-coded sample data.
 In a real-world app, the service might fetch data from a backend system.
 The key point, however, is that you control the hero job-application questions entirely through the objects returned from `QuestionService`.
 To maintain the questionnaire as requirements change, you only need to add, update, and remove objects from the `questions` array.
@@ -177,7 +177,7 @@ To display an instance of the dynamic form, the `AppComponent` shell template pa
 
 The example provides a model for a job application for heroes, but there are
 no references to any specific hero question other than the objects returned by `QuestionService`.
-This separation of model and data allows you to repurpose the components for any type of survey
+This separation of model and data lets you repurpose the components for any type of survey
 as long as it's compatible with the *question* object model.
 
 ### Ensuring valid data
@@ -187,7 +187,7 @@ without making any hardcoded assumptions about specific questions.
 It adds both control metadata and validation criteria dynamically.
 
 To ensure valid input, the *Save* button is disabled until the form is in a valid state.
-When the form is valid, you can click *Save* and the application renders the current form values as JSON.
+When the form is valid, click *Save* and the application renders the current form values as JSON.
 
 The following figure shows the final form.
 

aio/content/guide/form-validation.md

@@ -78,11 +78,10 @@ Angular then calls these functions whenever the value of the control changes.
 
 Validator functions can be either synchronous or asynchronous.
 
-* **Sync validators**: Synchronous functions that take a control instance and immediately return either a set of validation errors or `null`. You can pass these in as the second argument when you instantiate a `FormControl`.
+* **Sync validators**: Synchronous functions that take a control instance and immediately return either a set of validation errors or `null`. Pass these in as the second argument when you instantiate a `FormControl`.
 
 * **Async validators**: Asynchronous functions that take a control instance and return a Promise
-or Observable that later emits a set of validation errors or `null`. You can
-pass these in as the third argument when you instantiate a `FormControl`.
+or Observable that later emits a set of validation errors or `null`. Pass these in as the third argument when you instantiate a `FormControl`.
 
 For performance reasons, Angular only runs async validators if all sync validators pass. Each must complete before errors are set.
 
@@ -93,14 +92,14 @@ You can choose to [write your own validator functions](#custom-validators), or y
 The same built-in validators that are available as attributes in template-driven forms, such as `required` and `minlength`, are all available to use as functions from the `Validators` class.
 For a full list of built-in validators, see the [Validators](api/forms/Validators) API reference.
 
-To update the hero form to be a reactive form, you can use some of the same
+To update the hero form to be a reactive form, use some of the same
 built-in validators—this time, in function form, as in the following example.
 
 {@a reactive-component-class}
 
 <code-example path="form-validation/src/app/reactive/hero-form-reactive.component.1.ts" region="form-group" header="reactive/hero-form-reactive.component.ts (validator functions)"></code-example>
 
-In this example, the `name` control sets up two built-in validators&mdash;`Validators.required` and `Validators.minLength(4)`&mdash;and one custom validator, `forbiddenNameValidator`. (For more details see [custom validators](#custom-validators) below.)
+In this example, the `name` control sets up two built-in validators&mdash;`Validators.required` and `Validators.minLength(4)`&mdash;and one custom validator, `forbiddenNameValidator`. (For more details see [custom validators](#custom-validators).)
 
 All of these validators are synchronous, so they are passed as the second argument. Notice that you can support multiple validators by passing the functions in as an array.
 
@@ -127,7 +126,7 @@ Here's what the definition of that function looks like.
 
 The function is a factory that takes a regular expression to detect a _specific_ forbidden name and returns a validator function.
 
-In this sample, the forbidden name is "bob", so the validator will reject any hero name containing "bob".
+In this sample, the forbidden name is "bob", so the validator rejects any hero name containing "bob".
 Elsewhere it could reject "alice" or any name that the configuring regular expression matches.
 
 The `forbiddenNameValidator` factory returns the configured validator function.
@@ -185,7 +184,7 @@ If you were to replace `useExisting` with `useClass`, then you’d be registerin
 
 ## Control status CSS classes
 
-Angular automatically mirrors many control properties onto the form control element as CSS classes. You can use these classes to style form control elements according to the state of the form.
+Angular automatically mirrors many control properties onto the form control element as CSS classes. Use these classes to style form control elements according to the state of the form.
 The following classes are currently supported.
 
 * `.ng-valid`
@@ -258,7 +257,7 @@ To provide better user experience, the template shows an appropriate error messa
 
 <code-example path="form-validation/src/app/reactive/hero-form-reactive.component.html" region="cross-validation-error-message" header="reactive/hero-form-template.component.html"></code-example>
 
-This `*ngIf` displays the error if the `FormGroup` has the cross validation error returned by the `identityRevealed` validator, but only if the user has finished [interacting with the form](#dirty-or-touched).
+This `*ngIf` displays the error if the `FormGroup` has the cross validation error returned by the `identityRevealed` validator, but only if the user finished [interacting with the form](#dirty-or-touched).
 
 ### Adding cross-validation to template-driven forms
 
@@ -272,7 +271,7 @@ Because the validator must be registered at the highest level in the form, the f
 
 <code-example path="form-validation/src/app/template/hero-form-template.component.html" region="cross-validation-register-validator" header="template/hero-form-template.component.html"></code-example>
 
-To provide better user experience, we show an appropriate error message when the form is invalid.
+To provide better user experience, an appropriate error message appears when the form is invalid.
 
 <code-example path="form-validation/src/app/template/hero-form-template.component.html" region="cross-validation-error-message" header="template/hero-form-template.component.html"></code-example>
 
@@ -288,9 +287,9 @@ These are very similar to their synchronous counterparts, with the following dif
 To convert an infinite observable into a finite one, pipe the observable through a filtering operator such as `first`, `last`, `take`, or `takeUntil`.
 
 Asynchronous validation happens after the synchronous validation, and is performed only if the synchronous validation is successful.
-This check allows forms to avoid potentially expensive async validation processes (such as an HTTP request) if the more basic validation methods have already found invalid input.
+This check lets forms avoid potentially expensive async validation processes (such as an HTTP request) if the more basic validation methods have already found invalid input.
 
-After asynchronous validation begins, the form control enters a `pending` state. You can inspect the control's `pending` property and use it to give visual feedback about the ongoing validation operation.
+After asynchronous validation begins, the form control enters a `pending` state. Inspect the control's `pending` property and use it to give visual feedback about the ongoing validation operation.
 
 A common UI pattern is to show a spinner while the async validation is being performed. The following example shows how to achieve this in a template-driven form.
 

aio/content/guide/forms-overview.md

@@ -22,11 +22,11 @@ Reactive forms and template-driven forms process and manage form data differentl
 
 * **Reactive forms** provide direct, explicit access to the underlying forms object model. Compared to template-driven forms, they are more robust: they're more scalable, reusable, and testable. If forms are a key part of your application, or you're already using reactive patterns for building your application, use reactive forms.
 
-* **Template-driven forms** rely on directives in the template to create and manipulate the underlying object model. They are useful for adding a simple form to an app, such as an email list signup form. They're easy to add to an app, but they don't scale as well as reactive forms. If you have very basic form requirements and logic that can be managed solely in the template, template-driven forms could be a good fit.
+* **Template-driven forms** rely on directives in the template to create and manipulate the underlying object model. They are useful for adding a simple form to an app, such as an email list signup form. They're straightforward to add to an app, but they don't scale as well as reactive forms. If you have very basic form requirements and logic that can be managed solely in the template, template-driven forms could be a good fit.
 
 ### Key differences
 
-The table below summarizes the key differences between reactive and template-driven forms.
+The following table summarizes the key differences between reactive and template-driven forms.
 
 <style>
   table {width: 100%};
@@ -69,7 +69,7 @@ Both reactive and template-driven forms are built on the following base classes.
 
 * `FormArray` tracks the same values and status for an array of form controls.
 
-* `ControlValueAccessor` creates a bridge between Angular `FormControl` instances and native DOM elements.
+* `ControlValueAccessor` creates a bridge between Angular `FormControl` instances and built-in DOM elements.
 
 {@a setup-the-form-model}
 
@@ -225,7 +225,7 @@ The following examples demonstrate the process of testing forms with reactive an
 
 ### Testing reactive forms
 
-Reactive forms provide a relatively easy testing strategy because they provide synchronous access to the form and data models, and they can be tested without rendering the UI.
+Reactive forms provide a relatively straightforward testing strategy because they provide synchronous access to the form and data models, and they can be tested without rendering the UI.
 In these tests, status and data are queried and manipulated through the control without interacting with the change detection cycle.
 
 The following tests use the favorite-color components from previous examples to verify the view-to-model and model-to-view data flows for a reactive form.