JavaScript for Line of Business Applications

Jen Looper explains what observables are, why they are necessary for asynchronous communication and how to use them in an Angular 2 application with RxJS.

The conventional server rendering solution has saved us for years with Angular 1 by provisioning web crawlers with our actual content. That seemed to keep us happy but we were missing one thing -- state.

The Universal idea is to build an app that does not just render to server but also runs on the server. Running in the sense that our state, content and styles are intact on the client and the server as well. In Angular 2, this is achieved with the help of Angular Universal which loads our app on the server first, and then drops it to the browser once ready.

Learn the benefits Observables can provide when you are developing complex web applications.

While a Promise represents a value to be resolved in future, an Observable represents a stream of values throughout. An Observable may be completed, which means it won’t emit any further values. An Observer subscribes to these Observables. These Observers are essentially callbacks to emissions of the Observable. This paradigm supports asynchronous operations naturally. In our application, the Angular 2 components have functions which act as Observers, while the data-sharing service can act as an Observable.

In this tutorial we are going to look at what’s changed with forms and more importantly how to handle form validation the right way with Angular 2.

Angular 2.x aims to make the creation and validation of forms simple, intuitive, and manageable.

Some highlight technologies:

• Angular2 (typescript)
• WebApi (RESTful)
• Entity Framework
• Bootstrap
• IoC
• Multi-Layer architecture
• Modular your Application
• Multi Languages
• Design Pattern (Unit Of Work, Repository, …)
• SOLID principle
• Gulp
• NodeJs

What is it like to build an Angular 2 app, and how is the experience different from AngularJS?

Angular 2 is component based. Components combine concepts that we are already familiar with from AngularJS. The Angular 2 Component combines the AngularJS Directive, Controller, and Scope. My article will attempt to make you more comfortable with components by comparing them to what you already know from AngularJS.

Here are some tutorials that I worked through to prepare this. I will periodically link to code examples from them: Quickstart & Tour of Heroes

TypeScript is recommended for Angular 2. You will see the .ts file extension. I will point out TypeScript syntax where needed.

State management within Angular started out as a single celled organism if you will in the form of a single controller managing all the state for the application. If this is a single page application, one controller makes sense right? We emerged out of the ice age by starting to group our views and controllers into smaller, self-contained units either within a directive or a route. This was a vast improvement, but there was still the problem of managing complex state within our applications. It was not uncommon for us to have bits and pieces of state strewn across our application tucked inside of controllers, services, routes, directives, and occasionally, in our templates. Mutable state in itself is not inherently evil but shared mutable state is a recipe for disaster.

Angular claims to be very fast by default. What does “fast” really mean? Of course, this always depends on the context. What does our application do? How many different things is it doing at a certain point? How is our application’s component tree structured and how many bindings does it introduce? This and other questions come into play when trying to figure out, how we can make our applications faster.

A couple of weeks ago we were discussing a demo application in which we compared the default performance and what we can do to make it faster. In this article we’d like to take this demo and show some tips and tricks to make it blazingly fast. One or the other trick might help speeding up your application as well.

In this epic tutorial, we’re going to build some advanced Angular 2 components that rebuild Tesla’s battery range calculator and then compile it to AoT and deploy on GitHub pages. We’ll be using the reactive forms API as well and building custom form controls and use some stateful and stateless component practices, as well as change detection strategies.

This is the final project gif of what we’re about to build:

Follow these Angular 2 best practices to eliminate needless change detection, making your web app faster and cleaner.

In order to guarantee that the DOM always shows the very latest available data, Angular monkey-patches every entry point to running Javascript with a Zone. So any time Javascript finishes executing—meaning an AJAX request completes, a click event handler runs, or a Promise is fulfilled—Angular 2 checks whether any changes have occurred that would affect the DOM.

There's no recipe for building dynamic Angular 2 components on the fly, but that doesn't mean it can't be done. Here's our solution.

A dialog box is a good example of an Angular 2 component you may want to build on the fly. If your application has a fair number of them, and you feel put out at the thought of writing one large ngSwitch, then building them dynamically is a good alternative.