Prepare ourselves with some significant background info and a functioning development environment.

TypeScript is the language of choice for Angular2. Let’s learn why.

We need to get our Cloud9 online IDE set up and ready for development.

We’ll code every concept that we learn in our course project. Let’s set it up and get it ready for our first lesson.

Modules are a foundational part of Angular2. Let’s be sure to understand what they are and how we’ll use them.

We are now primed and ready to dive into Angular2.

Take a close look at what Angular2 components are and learn the steps involved in creating one.

Let’s learn what components are and what they’re made of.

Components consist of 3 parts. Let’s learn what they are and what each part does.

Let’s learn the interactions of the 3 component parts and how to stitch them together to create a complete component.

The App Component is the heart of an Angular2 application. Let’s learn to create it.

With enough ammunition to get an app up and running, let’s learn how to do it.

We learned enough to get an app up and running. With a very app is simple and very high-level Angular2 knowledge, we’re ready to dive deep into the Angular2 depths.

We will learn to define the visible aspects of components as HTML within a template.

Our view is defined in HTML which can then be inserted into our component’s template.

We can create a template in a separate file.

There are 3 steps in using a component as a directive.

Binding data from our component’s class to it’s template is easy with interpolation.

Angular2 has tons of built-in directives that we need.

We learned to work with templates within components, to bind data in those components, and how to use components as directives.

When data changes in our class, we need to reflect the change in our HTML. Let’s learn how this works.

Certain user interactions with our web page need to update properties in our class. We can use Event Binding to have this happen automatically.

We can use both Property binding and Event binding at the same time to synchronize class properties and page elements.

Let’s learn to use Pipes to transform bound properties before they are displayed.

In this section we learned to use Property binding & Event binding and how to combine them for 2-Way binding. We also learned how Pipes help us control the display of our data.

We will learn several ways to improve upon our components.

Let’s see how to make the most of Angular2’s TypeScript benefits thru use of Interfaces.

There is a better way to do styling in Angular2 than simply referencing a CSS file. Let’s learn how!

Let’s learn to listen to an Angular2 application and react to it’s many events.

We can transform and apply logic to data before we display it in the browser. Let’s see how it works.

In this section we learned to leverage TypeScript strong typing with interfaces, saw how to encapsulate styling within a component, and how to tap into component lifecycle events to trigger operations.

We will discus how to build components designed to be nested within other components and have these components talk to one another.

Let’s see how components can work “inside” other components.

We can use a Nested Component as a Directive. Let’s discuss how this is done..

Let’s learn how a Nested Component can take input from its Par

A Nested Component can send data to its Parent Component. Let’s examine this functionality.

In this section we learned how Components can nest within one another and still maintain normal data binding.

We can use Services when we have data or logic that is not associated with a specific view or that we want to share across components.

Let’s learn how Dependency Injection can make Services most effective

Services are created quite similarly to Components and Pipes. Let’s see how simple it really is.

Let’s learn to get Services into play by registering them as Providers.

We can leverage Dependency Injection to expose services where they’re needed.

In this section we learned to create Services, register them as Providers, and how to expose them most efficiently with Dependency Injection.

We will learn how to use HTTP with observable to retrieve data from the interwebs.

We can use Reactive Extensions (RxJS) to implement Angular2’s Observables instead of simply using Promises.

Let’s learn to get Reactive Extensions (RxJS) into play along with Angular2’s HTTP library.

We’ll learn to send HTTP requests in Angular2.

Let’s see how to use Observables to work with data requested via HTTP.

In this section we learned about using Reactive Extensions (RxJS) and it’s Observables instead of relying on Promises. We learned how Angular2’s HTTP library gets us HTTP requests and how to use Observables to handle data in an HTTP response.

We will learn to define routes for navigate between multiple views in an Angular2 application.

In Angular2 routing is component based. Let’s learn to configure routing targets and to define routes for components.

We will discuss the technique of tying routes to user actions for effective navigation within an application.

Oftentimes routes need to be passed a parameter. Let’s discover how this works in Angular2.

Let’s find out how to do routing with code vs. user interactions. We can implement Angular2’s RouterService to make this happen.

In this section we walked through how to configure routes, tie routes to actions, and define where the routed component’s view should appear. We also uncovered some additional routing techniques, including passing parameters to a route and activating a route with code.