---
title: 'The forgotten developer who saved JavaScript...'
source: 'https://youtube.com/watch?v=JfPWbttemYE'
video_id: 'JfPWbttemYE'
date: 2026-07-01
duration_sec: 388
---

# The forgotten developer who saved JavaScript...

> Source: [The forgotten developer who saved JavaScript...](https://youtube.com/watch?v=JfPWbttemYE)

## Summary

In 2009, JavaScript was widely considered the worst programming language, lacking standard library, modules, classes, and consistent browser support. Jeremy Ashkenas, a developer at DocumentCloud, set out to transform it by creating underscore.js, CoffeeScript, and Backbone.js. His innovations laid the groundwork for modern JavaScript, many features of which were later adopted into the language itself.

### Key Points

- **JavaScript's Dark Age** [0:00] — JavaScript in 2009 had no standard library, modules, or classes; every browser interpreted it differently.
- **underscore.js Released** [1:56] — Jeremy released underscore.js, a utility belt with ~60 helper functions for arrays/objects.
- **CoffeeScript Created** [3:10] — CoffeeScript created a new language that compiled to JavaScript, fixing bad parts like class syntax and arrow functions.
- **Backbone.js Introduced MVC** [4:26] — Backbone.js introduced MVC on the front end with models, collections, views, and an event system.
- **Modern JavaScript Adopts CoffeeScript Features** [3:52] — Many CoffeeScript features (classes, arrow functions, destructuring) were absorbed into modern JavaScript.

### Conclusion

Jeremy Ashkenas significantly improved JavaScript through underscore.js, CoffeeScript, and Backbone.js, many features of which were later adopted into the language itself.

## Transcript

It's 2009. You're at a Hannah Montana
movie and your phone won't stop buzzing
with notifications from a new dating app
you just downloaded. Your favorite
artist is supposed to be releasing a new
album next year. Your favorite TV show
is currently being made into a movie and
you're still riding high from arguing
how many days are in a week on the
bodybuilding.com forums. Life is good,
at least on the weekends, because during
the week you have to spend all day using
the worst programming language ever
invented, a language that was famously
designed in 10 days. But after using it,
it had you wondering what Brendan did
after day two. A language that every
browser interpreted differently, had no
standard library, modules, or classes.
And if your primary job was to write it,
I'm told you were a massive loser who
didn't deserve to feel loved. At least
that's how things were in 2009. But over
the next decade, that sentiment changed.
JavaScript went from being a language
that you'd never touch directly without
putting on a jQuery hazmat suit first to
arguably the most popular programming
language in the world. while JavaScript
developers, despite all the stupid
stickers on their MacBooks, went from
being considered script kitties to real
programmers with actual feelings and
emotions. So, how exactly did this mass
psychosis happen? There's a bunch of
different reasons, but in my opinion, I
think the most underrated was all led by
a single person who has since been
forgotten to time, Jeremy Ashkenus. In
2009, Jeremy was a developer at Document
Cloud, where he had the unfortunate task
of working on a heavy clientside
JavaScript application, which was rare
at that time. Having a background in
Ruby, but being forced to write
JavaScript, I assume every morning he'd
wake up and think to himself, "Wow,
today might be a good day to myself off
theing Golden Gate Bridge." But unlike
everyone else who had JavaScript
Stockholm syndrome, Jeremy had the
audacity to think he could fix it. And
so he did. His first act was dealing
with the fact that JavaScript had no
standard library. Again, this was 2009.
Although Firefox had shipped support for
some array helper methods like map,
reduce, and for each, Internet Explorer
hadn't yet, which meant you couldn't use
them unless you polyfilled them. So, to
fix this, Jeremy released underscore.js,
a utility belt library that contained
about 60 helper functions that made it
easier to work with arrays and objects.
Now, I know that doesn't sound exciting
today, but building for the web was so
bad back then that underscore likely did
save a few people from throwing
themselves off theing Golden Gate
Bridge. Underscore got so popular that
many of its features were adopted into
the JavaScript language itself, which
eventually made it obsolete. But
underscore was only Jeremy's first act.
Next, he decided instead of augmenting
fish head JavaScript with a new library,
he'd have more freedom if he just
created an entirely new language with
large cannons. Again, I can't stress
this enough. The JavaScript in 2009 was
very different than it is today. There
were no classes, so inheritance was done
through a pattern where you'd manually
attach properties to a hidden object
called prototype that every function had
access to. The only way to declare a
variable had bizarre scoping rules that
hoisted declarations to the top of a
function whether you were aware of it or
not. No one really understood or cared
about the difference between the
equality operator and the identity
operator is so you'd have a bunch of
type coercion happening without even
realizing it. And to define even a
simple function, you had to literally
type out the word function every single
time, which led to some pretty ugly
code. But by building a new language
that compiled a JavaScript, Jeremy could
fix it without having to wait for the
standards committee or browser vendors
to do it themselves. And even better, he
could leave JavaScript the bad parts in
that musty room Brendan spent 10 days
in. And for a while, Coffecript was
huge. The father DHH adopted it almost
overnight. And in 2011, it shipped as
the default JavaScript prep-processor in
Rails 3.1, meaning the front end for
every new Rails app in the world was
suddenly written in coffecript. A
GitHub, Dropbox, and a long list of
early 2010 startups adopted it. And for
a few years, it was the default choice
for anyone who took JavaScript
seriously. Today, Coffecript is
basically dead after its best features
were absorbed into JavaScript itself.
But every time your agent writes a
class, arrow function, default
parameters, a spread operator, does
string interpolation or dstructures a
value, you can thank coffecript. But
Jeremy still wasn't done yet. By 2010,
he had given JavaScript a standard
library with underscore and a better
syntax with coffecript. But there was
still one massive problem left. There
was no good way to actually structure a
JavaScript application. If you wanted to
build a large clientsideheavy app, you
would still end up with thousands of
lines of spaghetti where your data, DOM
manipulation, and event handlers were
all tangled together. So, in 2010,
Jeremy released Backbone.js, a tiny
library of less than 2,000 lines of code
that gave JavaScript developers their
first real taste of MVC on the front
end. It introduced models for your data,
collections for groups of models, views
for rendering, and an event system that
let everything stay in sync without the
need to wire it up by hand. But for the
first time, you could build a serious
clientside app without it collapsing
under its own weight. And with Jeremy's
track record, it quickly caught on,
powering the early versions of Trello,
Airbnb, Hulu, Pinterest, and basically
every other startup that needed a real
front end between 2011 and 2014. If you
were a JavaScript developer during that
window, you almost certainly wrote
Backbone and you probably thought it was
the future. But as it turns out, it
wasn't. Angular, Ember, and eventually
React would make Backbone obsolete by
taking its core ideas and pushing them
further. But Backbone was the library
that proved you could actually build
clientsideheavy applications. It's easy
to forget how bad JavaScript used to be,
and even easier to forget the people who
fixed it. But the modern web was built
on top of ideas that Jeremy Ashken has
pioneered, even if no one remembers him.
But speaking of things you no longer
have to build yourself, O is another one
that thanks to Clerk, the sponsor of
today's video, they just launched the
Clerk CLI, which comes with commands
that are even more powerful than the
ones I saw at that human dog show. Just
run Clerk andit in any directory, and
it'll set up endto-end authentication
for your entire project with custom
middleware, O pages, and environment
variables. It even detects if you're
migrating from next off or off zero and
walks you through the entire process.
And since they know you're using agents
to do all your dirty work, they also
created clerk skills which ships
framework specific patterns pinned to
the CLI version. They see your coding
agent knows exactly how to use it. And
the clerk API command lets your agent
hit the entire clerk backend API from
the terminal without copy and pasting
credentials. Try it out for free today
at the link below or just run clerk init
to get started. the thanks for watching
and I will see you in the next one.