From Making It Work to Making It Clear: Understanding Old vs Modern JavaScript

There was a time when writing JavaScript felt like improvisation.

You wrote what worked.

You adjusted when it broke.

And if it ran without errors, that was often enough.

That version of JavaScript still exists.

But somewhere along the way, the goal quietly changed.

It stopped being just about making things work.

And started becoming about making things understandable.

When Flexibility Was the Priority

In older JavaScript, flexibility was everywhere.

You could declare variables like this:

var count = 0

Functions behaved differently depending on how you called them.

The value of this could shift depending on context.

And much of the system relied on knowing subtle rules.

It was powerful.

But it also meant that understanding the code required understanding the environment it lived in.

Not just what was written…

but how it would behave.

The Hidden Cost of Implicit Behavior

One of the defining traits of older JavaScript was how much it left unsaid.

You could write:

console.log(this)

And what this meant depended entirely on where and how the function was executed.

Nothing in the code itself told you the answer.

You had to infer it.

And that kind of implicit behavior scales poorly.

Because as code grows, assumptions become harder to track.

A Shift Toward Clarity

Modern JavaScript didn’t remove those capabilities.

But it introduced tools to reduce ambiguity.

Instead of:

var count = 0

You now write:

let count = 0

Or even:

const count = 0

Not just for syntax.

But to communicate intent.

Is this value meant to change?

Or stay constant?

The code starts answering those questions directly.

Making Context Predictable

One of the biggest changes appears in how functions behave.

Arrow functions, for example, don’t redefine this.

They inherit it.

That small rule removes an entire category of confusion.

Instead of constantly asking:

“What is this here?”

You begin to trust that it won’t surprise you.

And that trust matters more than it seems.

From Mutation to Transformation

Older JavaScript often worked by changing things directly.

user.name = 'Rishi'

Modern JavaScript leans toward a different style.

const updatedUser = { ...user, name: 'Rishi' }

Instead of modifying the original…

you create a new version.

It may seem like a small shift.

But it changes how you think about data.

From something you change…

to something you derive.

From Global to Modular Thinking

There was also a time when scripts simply shared the same space.

<script src="a.js"></script>
<script src="b.js"></script>

Everything lived together.

Dependencies were implicit.

Modern JavaScript introduces modules.

import { something } from './module'

Now, relationships between pieces of code are visible.

Not assumed.

And that visibility becomes crucial as systems grow.

A Different Way to Describe Logic

Older JavaScript often described steps.

Do this.

Then do that.

Then update something.

Modern JavaScript leans toward describing transformations.

const result = items
  .filter(x => x.active)
  .map(x => x.name)

Less about how to do it.

More about what the result should be.

The code becomes closer to the intention.

Not Better, Just Different Priorities

It’s easy to look at this shift and say:

Modern JavaScript is better.

But that’s not quite right.

Older JavaScript was optimized for speed of writing.

You could move fast. Try things. Adjust quickly.

Modern JavaScript is optimized for clarity over time.

It asks you to be more explicit.

More deliberate.

Because the real cost of code isn’t writing it.

It’s understanding it later.

The Trade-off Beneath It All

At its core, the difference is a trade-off.

• flexibility vs predictability
• implicit behavior vs explicit intent
• short-term speed vs long-term clarity

Neither side is inherently wrong.

They just optimize for different moments in a project’s life.

A Subtle Realization

As projects grow, something interesting happens.

The code you wrote yesterday becomes something you need to understand today.

And something others need to understand tomorrow.

That’s where modern JavaScript begins to make more sense.

Not because it does more.

But because it hides less.

A Shift in Perspective

So the evolution from old to modern JavaScript isn’t really about new features.

It’s about a shift in mindset.

From:

“Can I make this work?”

To:

“Will this still make sense later?”

And once that question becomes part of how you write code…

the difference between old and modern JavaScript stops being technical.

And starts becoming intentional.