JavaScript tends to elicit two very common reactions:

"I don't understand why this works."
"JavaScript is inconsistent."

And the funny thing is that both phrases usually come from people who already write JavaScript every day.

After years of working with frontend, I came to a clear conclusion:
JavaScript is not difficult by nature. What is difficult is learning it poorly.

The problem isn't JavaScript, it's the context in which we learn it

Most of us learn JavaScript like this:

A quick course
A framework on top (React, Angular, Vue)
Copy and paste code that "already works"
Fixing errors without really understanding why they happened

This creates a false sense of progress. The project moves forward, but understanding does not.

When something goes wrong, JavaScript seems like black magic.

JavaScript was not designed for what it does today

JavaScript was born for very simple things:

Validating forms
Manipulating the DOM a little
Adding basic interactivity

It was not designed for:

Complex applications
Global states
Heavy asynchronous logic
Complete frontend architectures

The language grew as it went along, and many decisions that seem strange today make sense if you understand its history.

That doesn't make it bad, but it does require judgment.

The most common mistake: learning JavaScript from frameworks

Many developers "learn JavaScript" directly from React or Angular.

The problem is that frameworks:

Hide important details
Simplify complex concepts
Make the code work even if you don't understand it

This leads to confusion, such as:

this that changes value
Functions that "remember things" (closures)
promises that don't resolve when you expected
states that mutate without you noticing

The framework is not the problem.
The lack of fundamentals is.

The fundamentals that really matter in JavaScript

You don't need to know the entire language.
You need to master what affects 80% of your code.

Some key points:

Scope and closures
Understand why a function "remembers" variables and when that is good or dangerous.
Primitive types vs. references
Know when you're copying a value and when you're sharing memory.
Mutability
Most frontend bugs come from modifying things you shouldn't.
Event loop (mental model) You
don't need to memorize it, but you do need to understand why setTimeout or Promise they don't run when you expect them to.
Promises before async/await
async/await is just a more convenient way to write promises, not a conceptual replacement.

These fundamentals make everything else make sense.

JavaScript that "works" vs. professional JavaScript

There is a big difference between:

Code that works today
Code that someone else can maintain tomorrow

Professional JavaScript seeks:

Clarity over tricks
Intent over clever code
Predictability over "saving lines"

Most problems don't come from the language, but from poorly thought-out small decisions.

JavaScript and the modern frontend

Frameworks such as React or Angular reward good JavaScript:

Clear components
Predictable states
Well-separated logic

TypeScript helps, but it doesn't save you:

Bad decisions
Lack of understanding
Confusing code

TypeScript doesn't fix bad fundamentals. It
just makes them more obvious.

My stance as a frontend developer

I don't believe in fighting over tools.
I believe in understanding what you're doing and why.

JavaScript learned well:

Reduces bugs
Reduces stress
Makes your work more valuable

If you're building a solid career in frontend, JavaScript is not a step you can skip. It's the foundation.