In practice a synonym for Decoration.

A category of Directive that can listen to and modify the behavior of other HTML elements, attributes, properties, and components. They are usually represented as HTML attributes, hence the name.

The ngClass directive for adding and removing CSS class names is a good example of an Attribute Directive.

A barrel is an Angular library module consisting of a logical grouping of single-purpose modules such as Component and Directive.

Familiar barrels include angular2/core, angular2/common, angular2/platform/browser, angular2/http, and angular2/router.

Barrels are packaged and shipped as bundles that we may load with script tags in our index.html.

The script, angular2.dev.js, is a bundle.

Learn more in "Modules, barrels and bundles".

Almost always refers to Data Binding and the act of binding an HTML object property to a data object property.

May refer to a Dependency Injection binding between a "token" or "key" and a dependency provider. This more rare usage should be clear in context.

We launch an Angular application by "bootstrapping" it with the bootstrap method. The bootstrap method identifies an application's top level "root" Component and optionally registers service providers with the dependency injection system.

One can bootstrap multiple apps in the same index.html, each with its own top level root.

Angular JavaScript libraries are shipped in bundles within an npm package such as angular2.

The scripts angular2.dev.js, http.js, router.js, and Rx.js are familiar examples of bundles.

A bundle contains one more more barrels and each barrel contains a collection of logically related modules

Familiar barrels include angular2/core, angular2/common, angular2/platform/browser, angular2/http, angular2/router.

Learn more in "Modules, barrels and bundles".

An Angular class responsible for exposing data to a View and handling most of the view’s display and user-interaction logic.

The Component is one of the most important building blocks in the Angular system. It is, in fact, an Angular Directive with a companion Template.

The developer applies the @Component decorator to the component class, thereby attaching to the class the essential component metadata that Angular needs to create a component instance and render it with its template as a view.

Those familiar with "MVC" and "MVVM" patterns will recognize the Component in the role of "Controller" or "View Model".

Applications display data values to a user and respond to user actions (clicks, touches, keystrokes).

We could push application data values into HTML, attach event listeners, pull changed values from the screen, and update application data values ... all by hand.

Or we could declare the relationship between an HTML widget and an application data source ... and let a data binding framework handle the details.

Data Binding is that second approach. Angular has a rich data binding framework with a variety of data binding operations and supporting declaration syntax.

The many forms of binding include:

• Interpolation
• Property Binding
• Event Binding
• Attribute Binding
• Class Binding
• Style Binding
• Two-way data binding with ngModel

Learn more about data binding in the Template Syntax chapter.

A Decorator is a function that adds metadata to a class, its members (properties, methods) and function arguments.

Decorators are a JavaScript language feature, implemented in TypeScript and proposed for ES2016 (AKA ES7).

We apply a decorator by positioning it immediately above or to the left of the thing it decorates.

Angular has its own set of decorators to help it interoperate with our application parts. Here is an example of a @Component decorator that identifies a class as an Angular Component and an @Input decorator applied to a property of that component. The elided object argument to the @Component decorator would contain the pertinent component metadata.

@Component({...})
export class AppComponent {
  constructor(@Inject('SpecialFoo') public foo:Foo) {}
  @Input()
  name:string;
}

The scope of a decorator is limited to the language feature that it decorates. None of the decorations shown here will "leak" to other classes appearing below it in the file.

Dependency Injection is both a design pattern and a mechanism for creating and delivering parts of an application to other parts of an application that request them.

Angular developers prefer to build applications by defining many simple parts that each do one thing well and then wire them together at runtime.

These parts often rely on other parts. An Angular Component part might rely on a service part to get data or perform a calculation. When a part "A" relies on another part "B", we say that "A" depends on "B" and that "B" is a dependency of "A".

We can ask a "Dependency Injection System" to create "A" for us and handle all the dependencies. If "A" needs "B" and "B" needs "C", the system resolves that chain of dependencies and returns a fully prepared instance of "A".

Angular provides and relies upon its own sophisticated Dependency Injection system to assemble and run applications by "injecting" application parts into other application parts where and when needed.

At the core is an Injector that returns dependency values on request. The expression injector.get(token) returns the value associated with the given token.

A token is an Angular type (OpaqueToken). We rarely deal with tokens directly; most methods accept a class name (Foo) or a string ("foo") and Angular converts it to a token. When we write injector.get(Foo), the injector returns the value associated with the token for the Foo class, typically an instance of Foo itself.

Angular makes similar requests internally during many of its operations as when it creates a Component for display.

The Injector maintains an internal map of tokens to dependency values. If the Injector can't find a value for a given token, it creates a new value using a Provider for that token.

A Provider is a recipe for creating new instances of a dependency value associated with a particular token.

An injector can only create a value for a given token if it has a Provider for that token in its internal provider registry. Registering providers is a critical preparatory step.

Angular registers some of its own providers with every injector. We can register our own providers. Quite often the best time to register a Provider is when we bootstrap the application. There are other opportunities to register as well.

Learn more in the Dependency Injection chapter.

An Angular class responsible for creating, re-shaping, and interacting with HTML elements in the browser DOM. Directives are Angular's most fundamental feature.

A Directive is almost always associated with an HTML element or attribute. We often refer to such an element or attribute as the directive itself. When Angular finds a directive in an HTML template, it creates the matching directive class instance and gives that instance control over that portion of the browser DOM.

Developers can invent custom HTML markup (e.g., <my-directive>) to associate with their custom directives. They add this custom markup to HTML templates as if they were writing native HTML. In this way, directives become extensions of HTML itself.

Directives fall into one of three categories:

1. Components that combine application logic with an HTML template to render application [views]. Components are usually represented as HTML elements. They are the building blocks of an Angular application and the developer can expect to write a lot of them.

2. Attribute Directives that can listen to and modify the behavior of other HTML elements, attributes, properties, and components. They are usually represented as HTML attributes, hence the name.

3. Structural Directives, a directive responsible for shaping or re-shaping HTML layout, typically by adding, removing, or manipulating elements and their children.

The official JavaScript language specification.

The latest approved version of JavaScript is ECMAScript 2015 (AKA "ES2015" or "ES6") and many Angular 2 developers will write their applications either in this version of the language or a dialect that strives to be compatible with it such as TypeScript.

Most modern browsers today only support the prior "ECMAScript 5" (AKA ES5) standard. Applications written in ES2015 or one of its dialects must be "transpiled" to ES5 JavaScript.

Angular 2 developers may choose to write in ES5 directly.

The lastest released version of JavaScript, ECMAScript 2015 (AKA "ES2015" or "ES6")

Short hand for "ECMAScript 2015".

Short hand for "ECMAScript 2015".

Short hand for "ECMAScript 5", the version of JavaScript run by most modern browsers. See ECMAScript.

An object in the Angular dependency injection system that can find a named "dependency" in its cache or create such a thing with a registered provider.

A directive property that can be the target of a Property Binding. Data values flow into this property from the data source identified in the template expression to the right of the equal sign.

See the Template Syntax chapter.

A form of Property Data Binding in which a template expression between double-curly braces renders as text. That text may be concatenated with neighboring text before it is assigned to an element property or displayed between element tags as in this example.

My current hero is {{hero.name}}

Learn more about interpolation in the Template Syntax chapter.

Directives and Components have a lifecycle managed by Angular as it creates, updates and destroys them.

Developers can tap into key moments in that lifecycle by implementing one or more of the "Lifecycle Hook" interfaces.

Each interface has a single hook method whose name is the interface name prefixed with ng. For example, the OnInit interface has a hook method names ngOnInit.

Angular calls these hook methods in the following order:

• ngOnChanges - called when an input/output binding values change
• ngOnInit - after the first ngOnChanges
• ngDoCheck - developer's custom change detection
• ngAfterContentInit - after component content initialized
• ngAfterContentChecked - after every check of component content
• ngAfterViewInit - after component's view(s) are initialized
• ngAfterViewChecked - after every check of a component's view(s)
• ngOnDestroy - just before the directive is destroyed.

Learn more in the Lifecycle Hooks chapter.

Angular apps are modular.

In general, we assemble our application from many modules, both the ones we write ourselves and the ones we acquire from others.

A typical module is a cohesive block of code dedicated to a single purpose.

A module exports something of value in that code, typically one thing such as a class. A module that needs that thing, imports it.

The structure of Angular modules and the import/export syntax is based on the ES2015 module standard described here.

An application that adheres to this standard requires a module loader to load modules on request and resolve inter-module dependencies. Angular does not ship with a module loader and does not have a preference for any particular 3rd party library (although most samples use SystemJS). Application developers may pick any module library that conforms to the standard

Modules are typically named after the file in which the exported thing is defined. The Angular DatePipe class belongs to a feature module named date_pipe in the file date_pipe.ts.

Developers rarely access Angular feature modules directly. We usually import them from public-facing library modules called barrels. Barrels are groups of logically related modules. The angular2/core barrel is a good example.

Learn more in "Modules, barrels and bundles".

A directive property that can be the target of an Event Binding. Events stream out of this property to the receiver identified in the template expression to the right of the equal sign.

See the Template Syntax chapter.

An Angular pipe is a function that transforms input values to output values for display in a view. We use the @Pipe decorator to associate the pipe function with a name. We then can use that name in our HTML to declaratively transform values on screen.

Here's an example that uses the built-in currency pipe to display a numeric value in the local currency.

Price: {{product.price | currency}}

Learn more in the chapter on pipes .

A Provider creates a new instance of a dependency for the Dependency Injection system. It relates a lookup token to code - sometimes called a "recipe" - that can create a dependency value.

For example, new Provider(Foo, {useClass: Foo}) creates a Provider that relates the Foo token to a function that creates a new instance of the Foo class.

There are other ways to create tokens and recipes. See Dependency Injection chapter to learn more.

Most applications consist of many screens or views. The user navigates among them by clicking links and buttons and taking other similar actions that cause the application to replace one view with another.

The Angular Component Router is a richly featured mechanism for configuring and managing the entire view navigation process including the creation and destruction of views.

A Component with an attached router.

In most cases, the component became attached to a router by means of a @RouterConfig decorator that defined routes to views controlled by this component.

The component's template has a RouterOutlet element where it can display views produced by the router.

It likely has anchor tags or buttons with RouterLink directives that users can click to navigate.

A category of Directive that can shape or re-shape HTML layout, typically by adding, removing, or manipulating elements and their children.

The ngIf "conditional element" directive and the ngFor "repeater" directive are good examples in this category.

A template is a chunk of HTML that Angular uses to render a view with the support and continuing guidance of an Angular Directive, most notably a Component.

We write templates in a special Template Syntax.

An expression in a JavaScript-like syntax that Angular evaluates within a data binding. Learn how to write template expressions in the Template Syntax chapter.

The process of transforming code written in one form of JavaScript (e.g., TypeScript) into another form of JavaScript (e.g., ES5).

A version of JavaScript that supports most ECMAScript 2015 language features and many features that may arrive in future versions of JavaScript such as Decorators.

TypeScript is also noteable for its optional typing system which gives us compile-time type-checking and strong tooling support (e.g. "intellisense", code completion, refactoring, and intelligent search). Many code editors and IDEs support TypeScript either natively or with plugins.

TypeScript is the preferred language for Angular 2 development although we are welcome to write in other JavaScript dialects such as ES5.

Angular 2 itself is written in TypeScript.

Learn more about TypeScript on its website.

A view is a portion of the screen that displays information and responds to user actions such as clicks, mouse moves, and keystrokes.

Angular renders a view under the control of one or more Directives, especially Component directives and their companion Templates. The Component plays such a prominent role that we often find it convenient to refer to a component as a view.

Views often contain other views and any view might be loaded and unloaded dynamically as the user navigates through the application, typically under the control of a router.

Zones are a mechanism for encapsulating and intercepting a JavaScript application's asynchronous activity.

The browser DOM and JavaScript have a limited number of asynchronous activities, activities such as DOM events (e.g., clicks), promises, and XHR calls to remote servers.

Zones intercept all of these activities and give a "zone client" the opportunity to take action before and after the asynch activity completes.

Angular runs our application in a zone where it can respond to asynchronous events by checking for data changes and updating the information it displays via data binding.

Learn more about zones in this Brian Ford video.