What Angular is, and how it's put together

Intermediate · 16 min

Angular's philosophy as a full platform, its core packages, and where it sits next to React and Vue.

Code Hub · 16 min

What Angular is, and how it's put together

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by Code HubReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • Angular is a full platform — components, DI, routing, forms, and an HTTP client all ship and version together, not a view library you bolt tools onto.
  • It's been TypeScript-first since its 2016 rewrite, not retrofitted later the way most JS tooling adopted types.
  • The "Angular vs React" question is really a platform vs. a library plus whatever you pick — the comparison only makes sense once you know what's actually inside the box.

The problem every framework is answering

Open a blank HTML file and you have exactly three tools: markup, styles, and a scripting language that was never designed to build applications. No concept of a component. No built-in way to move between “pages” without a full reload. No agreed-upon way to talk to a server, validate a form, or share state between two unrelated parts of the page.

None of that is a flaw in the browser — it’s not the browser’s job. But the moment you’re building something bigger than a script that swaps a few divs around, you need answers to all of those problems, and you need them to agree with each other. A router that doesn’t know how your components are structured is useless. A form library that assumes a different reactivity model than the rest of your app creates friction at every seam. This is the actual reason frameworks exist: not to make HTML “nicer,” but to give you one coherent, pre-agreed set of answers instead of assembling your own from a dozen unrelated libraries.

Angular’s answer: one platform, not a pile of libraries

Angular’s bet is that those answers should ship together, versioned together, and designed to assume each other exist. @angular/core gives you components, dependency injection, and change detection. @angular/common gives you the built-in directives and pipes every template reaches for, plus — in @angular/common/http — the HTTP client. @angular/forms gives you both the template-driven and reactive ways to build and validate forms. @angular/router gives you navigation, nested routes, and guards. When a new major version ships, all of these move together, tested against each other, documented against each other.

Compare that to a typical React setup: React itself is a rendering library, full stop. Routing is a separate choice (react-router, TanStack Router, or your own nested-switch mess). Forms are a separate choice. State management is a separate choice, sometimes several different choices stacked on top of each other depending on which blog post the team read that year. That’s not a knock on React — it’s a genuinely different bet, optimized for flexibility over agreement. Vue sits somewhere between the two: a smaller, more opinionated core than React, with an official router and state library, but still looser coupling than Angular’s single platform.

Neither bet is “correct.” A platform that ships its own router and forms library makes a large team’s codebases look more alike, at the cost of flexibility you don’t always need. A library-plus-your-own-choices setup gives you more freedom, at the cost of every team reinventing (or disagreeing about) the same wiring. The video for this lesson spends its Angular section walking through exactly this trade-off against React and Vue — worth watching with this framing in mind rather than treating it as a popularity contest.

TypeScript from the ground up, not bolted on

Angular rewrote itself from scratch in 2016 (what most people call “Angular 2,” to distinguish it from the original AngularJS), and that rewrite was TypeScript-first from day one. That’s a different thing from “a JavaScript framework that happens to ship type definitions.” Angular’s own APIs are built assuming a type checker is present: decorators like @Component and @Injectable carry metadata that tooling reads at compile time, dependency injection is wired through constructor parameter types, and HttpClient is generic — http.get<User>(url) tells you, and your editor, exactly what comes back. None of that works as cleanly if types are an afterthought layered on top of a JavaScript API that was never designed with them in mind.

What you actually get when you ng new

Every one of the pieces above is a real, separately-versioned npm package — you’ll see @angular/core, @angular/common, @angular/forms, and @angular/router as explicit dependencies the moment you generate a new project. The next lesson walks through exactly what the CLI generates and how a modern Angular app boots, so you can see these packages in a real file tree instead of as names on a slide.

Check yourself

  1. 01If you start a new React project and a new Angular project, which one hands you a router and an HTTP client out of the box?

    Angular. React gives you a rendering library; routing, forms, and HTTP are your own choices (react-router, your fetch wrapper, etc.). Angular ships `@angular/router` and `@angular/common/http` as part of the same release.

  2. 02Why does it matter that Angular was TypeScript-first from the start, rather than JavaScript with types added later?

    The framework's own APIs — decorators, dependency injection, generics in `HttpClient<T>` — are designed assuming a type checker is watching. Bolt-on typing (like early `@types` packages for other frameworks) can only describe an API after the fact; it can't shape how that API was designed.

Go deeper

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark