6:40
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.
