What Angular is, and how it's put together
Angular's philosophy as a full platform, its core packages, and where it sits next to React and Vue.
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.
Not started
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
If 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.
Why 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
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.