Last updated: 13.04.2020
Angular and React stand as the two dominant web technologies in 2020. This piece examines their backgrounds, fundamental distinctions, and the languages they advocate—TypeScript for one, JavaScript for the other. Both have simplified code reuse, refactoring, and maintenance through a component-based approach.
The intention here isn't to crown a winner but to lay out differences, clear up common misunderstandings, and direct focus toward what truly matters over the long haul rather than trivia.
A full comparison is impossible: Angular is a complete MVC framework, while React is a library for views, supplemented by a vast ecosystem of packages. Angular resembles a fully stocked toolkit, whereas React offers a minimal core with many integration choices.
Questions this piece addresses
- What sets Angular and React apart?
- Why does TypeScript get so much attention?
- How do these technologies rank in popularity?
- What's the state of their open-source communities?
- Which one do major companies adopt?
- Do static types improve code and speed up development?
Future additions will depend on reader interest expressed in the comments.
Side-by-side
A quick reference for Angular (left) versus React (right).
Angular and React
React's Virtual DOM is a frequently touted performance feature. If it's unfamiliar, here's the explanation.
The issue
Picture changing a user's birth date nested inside several layers of HTML.
Virtual DOM
It compares the previous and current HTML snapshots, updating only the necessary chunk—much like how GitHub highlights file changes.
Regular DOM
It rebuilds the entire HTML structure from the top down, even if the change is tiny.
Why this matters
A single update might not be noticeable. However, when a page handles 20–30 asynchronous data calls and each response replaces the whole block, performance and user experience suffer.
For deeper context, see Dace's article!
But let's go back to the start…
Background
Understanding a bit of history helps predict future directions.
I'll skip the full story of the AngularJS to Angular transition—plenty of resources cover it. The short version: Google swapped out the old framework and its language, adopting TypeScript.
During the ES4/ES5 era, JavaScript had a steep learning curve, especially for developers coming from Java, C#, or C++. These programmers were used to object-oriented programming (OOP), and JavaScript didn't feel intuitive; it was frustrating.
The language wasn't poorly designed—it just served a different purpose. JavaScript handles the web's asynchronous nature: user interactions, event handling, animations, and so on. It's a fundamentally different beast.
Adoption trends
Google Trends data shows both Angular and React as leading web technologies in 2020.
Around May 2018, search interest shifted, with React becoming more popular. This isn't a quality judgment but a signal of what intrigues people online. Also, some of Angular's search traffic may be attributed to AngularJS queries.
Both are growing steadily, so concerns about long-term support are unfounded.
It's worth remembering the AngularJS saga as a precedent. Such overhauls can happen to any framework, including React; that's just how the industry evolves. But given the improvements, the decision seems justified.
Google Trends Angular vs React
Open-source metrics
React boasts over 100,000 stars, around 1200 contributors, and roughly 300 open issues.
React launched three years before Angular, giving it a head start in market presence. That extra time meant tackling real-world problems, passing rigorous tests, and evolving into the flexible library developers now appreciate.
Angular's GitHub shows nearly 6 times more issues than React, which looks concerning. But context matters: Angular is a bigger framework with a smaller current user base, having only arrived in 2016.
Angular
- Stars: 60.000
- Contributors: 1100
- Issues: 3000
React
- Stars: 150.000
- Contributors: 1400
- Issues: 500
Source: Angular and React's GitHub pages.
Company adoption
Facebook created React to streamline its own development. Chris Cordle notes React is used more heavily at Facebook than Angular is at Google.
Who uses what?
# React
- AirBnb
- Uber
- Netflix
- Dropbox
# Angular
- Eat24
- CVS shop
- onefootball
- Google Express
- NBA
- Delta
- wix.com
Know of other big-name Angular users? Please share links.
TypeScript and JavaScript (ES6+)
Comparing Angular and React without considering their recommended languages misses a key part of the picture.
Note! This is not about picking a side. It's about clearing up long-standing misconceptions about static versus dynamic typing, with research to back it up.
TypeScript (left) vs JavaScript (right)
JavaScript has a much larger user base. But TypeScript is growing fast; who knows what the next decade will bring.
TypeScript's rise over 5 years
Google Trends — TypeScript popularity
JavaScript's steady presence over 5 years
Google Trends — JavaScript popularity
Comparing their search trends
Google trends — TypeScript and JavaScript popularity
Microsoft introduced TypeScript in October 2012 to make JavaScript—specifically ES5—more approachable. It's a transpiler that converts TypeScript into JavaScript, so you can even write ES5 within a .ts file. That's why it's called a superset of JavaScript.
TypeScript was a bridge for OOP developers. At its release, ES5 lacked class-based structures; nearest you could get was prototype inheritance—a tough hurdle for many. TypeScript offered a familiar, comfortable alternative.
JavaScript has since evolved significantly. Features like modules, classes, spread operators, arrow functions, and template literals now support declarative, OOP-style code with a proper class structure.
Static vs. dynamic typing
Static typing lets you declare a variable's type (e.g., string, number, array). Why does that matter? Here's an analogy.
Think about fueling a car. You need the right kind: petrol or diesel. Get it wrong, and you might need a new engine.
Coding isn't usually that drastic, but it can feel that way. In a large app, knowing what type of arguments and properties you're dealing with is crucial; otherwise, you risk breaking things.
Still fuzzy? See these examples:
Typed property example
Static typed property comparison between JavaScript and TypeScript
Typed argument example
Static typed argument comparison between JavaScript and TypeScript
Many assume static typing guarantees more reliable code, and use it as a decisive argument. It's actually hard to prove or disprove; it depends on the environment, the developer, and the project.
Fortunately, research (short video) tested this myth with 49 participants.
What the study found:
- Static typing took longer due to fixing type errors
- Dynamic typing was more readable and faster to write
Figure 5 shows developers are, on average, twice as fast with dynamically typed languages.
For more, check out Eric Elliott's take on why you might not need TypeScript.
Making the choice
The decision isn't just about Angular vs. React; it's also about which language you'll invest in. Both are valid as long as they suit your needs and project complexity.
Don't like types? Write plain ES6 in a TypeScript file. The option is there when you need it.
For a large Angular app with many HTTP calls, types are handy: “What object is this? What fields does it have? What type are they?” It clarifies collaboration and simplifies details.
Here's a simple class comparison in both.
TypeScript
JavaScript (ES6)
Personal take
Static typing can feel structured, secure, and clear for collaboration. Dynamic typing offers more freedom and creative flow, without getting bogged in types and interfaces.
In my past projects, I haven't hit serious problems without static types. I don't dislike it; I just haven't needed it—though maybe that will change.
Currently, I'm working with Microsoft developers on an Angular app. We picked it because everything's included and documented in one place. TypeScript suits the team well since most are strong in OOP.
But I've also seen similar apps built successfully with React. Both are powerful; it really comes down to architecture.
Key takeaways
- TypeScript is just a transpiler; it works with React or any JS framework
- React handles memory efficiently with the virtual DOM
- React uses JavaScript (ES6), a web staple since 1995
- Angular uses TypeScript, which arrived in 2012
- Static typing is helpful but not essential
- Dynamic typing speeds up initial coding and boosts flexibility
- Learning static typing can be tough, especially for dynamic-language veterans
- ES6 introduced modules, classes, spread syntax, arrow functions, and template literals for cleaner code
- TypeScript is essentially ES6+ with types and extra features
Wrapping up
Your choice affects development cost and speed. A team familiar with C#, Java, or C++ would likely find Angular's TypeScript approach familiar and advantageous.
Not sure which to use? Build a small test app in both and evaluate the language and workflow. Choose based on that experience.
Both have pros and cons, and the right answer depends on the application's specific requirements, its complexity, and your team's expertise.
Related reading on the web ecosystem and programming practices.
- A chaotic mind leads to chaotic code
- Developers that constantly want to learn new things
- A practical guide to ES6 modules
- Learn these core Web Concepts
- Boost your skills with these important JavaScript methods
- Program faster by creating custom bash commands
Enjoyed this? Clap ❤ and share it with friends—it's good karma.