Angular 2 Finally Ships

Angular 2.0 shipped this week, two years after announcement. The wait was long, the changes are total, and the reception is mixed. Google rebuilt Angular from scratch—TypeScript, component-based, completely different API. Whether this was right decision depends on who you ask.

What's certain: the two-year rewrite gave React enormous opportunity.

What Took So Long

Angular 2 was announced September 2014. Final release: September 2016. Two years is an eternity in JavaScript.

The delay wasn't laziness—Angular 2 is complete rewrite:

• New language (TypeScript)
• New architecture (components vs controllers)
• New templating syntax
• New dependency injection
• New everything

This wasn't iterative improvement. It was replacement. That takes time.

But two years gave competitors time to mature. React gained massive adoption. Vue emerged. Ember shipped multiple stable releases. Angular ceded ground.

The Breaking Changes Reality

Angular 2 broke compatibility with Angular 1 completely. No migration path except rewriting. This forced decision on Angular 1 teams: migrate to Angular 2 (rewrite) or switch frameworks entirely.

Many switched. To React, mostly. If rewriting is required anyway, why stay with Angular?

Google argued: Angular 1's architecture couldn't support modern needs. Performance, mobile, TypeScript—these required fresh start.

Fair argument. But breaking compatibility with millions of Angular 1 apps is costly. Whether the benefits justify costs is debatable.

The TypeScript Commitment

Angular 2 is written in TypeScript and documentation assumes TypeScript. Technically you can use ES6, but TypeScript is first-class.

This is controversial. TypeScript has benefits (tooling, types, etc.) but learning curve is real. Teams using plain JavaScript face extra hurdle.

The partnership with Microsoft (TypeScript's creator) helped both: Angular legitimizes TypeScript, TypeScript gives Angular better tooling.

But it's opinionated choice that excludes developers who reject static typing.

The Component Model

Angular 2's architecture is component-based:

@Component({
  selector: 'user-profile',
  template: `
    <h1>{{user.name}}</h1>
    <button (click)="save()">Save</button>
  `
})
export class UserProfile {
  @Input() user: User;
  
  save() {
    // save logic
  }
}

This is cleaner than Angular 1's controllers, directives, services tangled architecture. Components are self-contained, composable units.

This architecture mirrors React's approach. Angular 2 borrowed liberally from React's ideas. One-way data flow, component trees, explicit data passing—these are React patterns.

Performance Improvements

Angular 1's dirty checking performance issues are well-known. Angular 2 addresses this:

Change detection strategies: Default checks everything, OnPush checks only when inputs change

Ahead-of-time compilation: Templates compile to JavaScript before deployment

Lazy loading: Load modules on demand

Better rendering: Optimized DOM updates

These improvements are real. Angular 2 apps perform significantly better than Angular 1 equivalents.

But React's performance is also good. "Faster than Angular 1" isn't unique selling point when React is already fast.

The Mobile Story

Angular 2 was designed for mobile from start. NativeScript integration, better touch handling, smaller payload, faster rendering—mobile was priority.

But React Native shipped in 2015 and gained traction during Angular 2's development. React Native's "write once, truly native" approach is compelling.

Angular's mobile story is solid but React Native's head start matters.

The Ecosystem Restart

Angular 2's incompatibility meant ecosystem restart:

• Angular 1 libraries don't work
• Router completely different
• Forms handling different
• HTTP client different
• Everything different

Libraries, tools, tutorials—all had to be rebuilt. This cost the community momentum.

React's ecosystem continued evolving throughout this period. Redux, React Router, ecosystem maturation—these happened while Angular rebuilt.

When Angular 2 Makes Sense

Angular 2 is compelling for:

• Enterprise teams wanting opinionated framework
• Teams using TypeScript
• New projects starting fresh
• Teams that value comprehensive out-of-box solution

Angular 2 is questionable for:

• Existing Angular 1 codebases (migration is rewrite)
• Teams using JavaScript (TypeScript adds friction)
• Projects where React's flexibility is preferred
• Teams burned by Angular 1 → 2 breaking changes

The Trust Problem

The breaking changes damaged trust. If Angular 3 breaks everything again, why invest?

Google says Angular 2+ will evolve incrementally. Semantic versioning, predictable releases, no more rewrites.

But trust is earned, not declared. Angular needs to prove stability over years before developers feel safe investing deeply again.

Comparison to React

React vs Angular 2 comparison is inevitable:

React:

• Flexible, bring your own architecture
• JavaScript-first (JSX is still JavaScript)
• Large ecosystem, established patterns
• React Native for mobile

Angular 2:

• Opinionated, comprehensive framework
• TypeScript-first
• Official solutions for routing, forms, HTTP
• NativeScript for mobile (less mature than React Native)

Neither is objectively better. They serve different preferences.

Looking Forward

Angular 2's success depends on:

1. Proving stability (no more rewrites)
2. Growing ecosystem
3. Convincing developers to give Angular second chance
4. Delivering on TypeScript/mobile promises

If these happen, Angular 2 could be serious React competitor. If not, it might be cautionary tale about breaking compatibility.

For now, Angular 2 is viable choice for new projects. Whether it regains Angular 1's dominance is unlikely—the JavaScript landscape is too fragmented.

The two-year wait was costly. Time will tell if the architectural improvements justify the cost.

Resources:

• Angular
• Angular CLI
• TypeScript