Welcome to The Stack Unpacked.
This is a new series where I’ll be unpacking the stacks, tools, and technologies we use to build modern software — piece by piece. Think of it as part deep-dive, part history lesson, and part therapy session for anyone who’s ever stared at their screen thinking: “Wait… how does this actually work?”
This series is especially for newer developers (and for those of us who’ve been around a while but still feel lost at times). If you’re a seasoned dev, you’ll probably laugh at our confusion — but maybe you’ll also remember what it felt like to be in our shoes.
So, before we get into React, TypeScript, or any of the big players, let’s set the stage. Today we’re looking at how software engineering has evolved: the “then” versus the “now.”
Because here’s the thing: the way we build software today — with GitHub, AWS, and shiny frameworks — is the result of decades of trial, error, and, occasionally… absolute chaos.
Let’s rewind the clock.
The Early Days: Punch Cards, COBOL
Back in the ‘60s and ‘70s, software wasn’t even the star of the show. Hardware was king. Computers were the size of rooms, and the software? That was just the annoying stuff you had to write so the hardware actually did something.
The dominant language of the era was COBOL (Common Business Oriented Language). It was supposed to be readable by non-programmers like business managers. The thing is, most managers still looked at it and went, “Nope. Gibberish.”
Programming back then was high stakes. You’d write code by hand, punch it onto cards, feed them into the machine, and wait. If you made a typo? Congratulations, you just wasted a day. Debugging often meant carrying stacks of punched cards and praying you didn’t drop them, because if you did then you've just scrambled up the program.
And here’s the kicker: COBOL is still alive.
In fact, I bumped into it myself. My first real tech job was at a company that had just ported their old COBOL system into Delphi. At first, I was fixing alignment issues — literally dragging boxes around on a screen. But eventually, I was tasked with building a new screen for the system.
The only reference I had was the old COBOL code.
Reading that COBOL felt like someone had handed me a 200-page terms and conditions agreement and said: “Here, make a UI out of this.” It made no sense. The only way forward was to hunt down the SQL queries and piece the puzzle together from there. Honestly? If you gave me that code today, I’d probably still squint at it thinking, “What even is this?”
COBOL may feel like ancient history, but it still powers critical systems today — from banks to payroll to government infrastructure. Replacing it is like trying to swap the engine of a jet mid-flight… while carrying the global economy as passengers.
From Mainframes to the Family PC
By the 1980s, computers started shrinking from room-sized beasts into something you could actually put on a desk. This was the rise of the personal computer.
Languages like C exploded in popularity. It was powerful yet human-readable, and it became the foundation for much of modern programming. C is the great-great-grandparent of languages like C++, Java, and Go.
But while the industry was busy laying the foundation for modern software, many of us just had those beige family PCs with giant CRT monitors.
In my case, my dad would sometimes bring home chunky box, sometimes there would be 2 or more discs in them. That was my ticket to a new game. At first, he installed them for me. But eventually, he just said, “Figure it out.”
So I did — and learned the golden rule: click “Next,” accept everything, and pray. (Don’t try that today unless you want twelve new subscriptions, a toolbar you can’t uninstall, and a browser extension mining Bitcoin while you sleep.)
That early curiosity — tinkering, breaking things, figuring it out by accident — is the same spirit that drives software engineers today.
The Rise of the Internet
Then came the 1990s, and with it, the internet.
Early websites were mostly static text with the occasional horrifying background MIDI track. It was basically the digital equivalent of fridge magnets. You could move them around, but they weren't really interactive enough.
But this decade also gave us the languages that powered the web:
- Java (1995): Promised us “write once, run anywhere.”
- PHP (1995): Started as a few personal homepage scripts. And accidentally grew into one of the most popular server-side languages.
- JavaScript (1995): Brendan Eich created the first version in just 10 days at Netscape. Originally called Mocha, then LiveScript, it finally became JavaScript (despite having nothing to do with Java). It gave web pages interactivity — buttons that actually did something without reloading the page. Magic at the time.
This was also the era of the Browser Wars: Netscape Navigator vs Internet Explorer. Developers had to write code twice and still watch it break half the time. “Best viewed in Internet Explorer” banners were everywhere.
By the late ‘90s, the web wasn’t just a curiosity. It was exploding. Dot-com startups were everywhere, things were being sold online, and coding for the web became one of the hottest tickets in town.
The Dot-Com Bubble and the Birth of Web 2.0
The late ‘90s and early 2000s brought the dot-com bubble. Money flowed into anything with “.com” slapped on the end. And most of those companies had no idea what they were doing, so by 2000, the bubble burst.
But out of that chaos came Web 2.0 — the shift from a read-only web to a read-write one.
- Blogs let anyone publish their thoughts.
- Wikipedia somehow made an encyclopedia built by strangers actually work.
- Social media began — Friendster, MySpace, and eventually Facebook.
For me, I was late to the Facebook party. But once I joined, I remember posting on my wall about random things I was interested in — and trying way too hard to be funny. Let’s just say… not all of those posts aged well.
Under the hood, new tools drove this era forward:
- AJAX allowed web pages to update parts of the screen without reloading.
- Gmail (2004) proved a browser app could be slick and fast.
- The LAMP stack (Linux, Apache, MySQL, PHP) powered countless Web 2.0 startups.
- jQuery became duct tape for the web, making cross-browser code less painful.
The foundation for today’s interactive, user-driven web was set.
The 2010s: Mobile First, Cloud Everything
The 2010s brought the smartphone revolution. Suddenly, apps had to work not just on desktops but on tiny touchscreens. Responsive design became essential, and tools like Bootstrap arrived to save developers from CSS-induced breakdowns.
Meanwhile, AWS made cloud hosting mainstream. Why buy servers when you could rent Amazon’s? With a credit card, you could spin up infrastructure in minutes.
JavaScript also broke free of the browser with Node.js (2009), allowing it to run on servers. Suddenly, full-stack JavaScript was possible.
And in 2013, React dropped. Components changed everything. Instead of spaghetti code, apps could be built from reusable Lego-like pieces. Frameworks like Angular and Vue joined the party, giving us the modern frontend landscape.
The backend shifted too — from LAMP to stacks like MERN (MongoDB, Express, React, Node). APIs (REST, then GraphQL) became the glue connecting services.
By the end of the decade, the modern stack looked a lot like what many of us use today:
- React or similar frameworks for the frontend.
- Node.js, Python, Go, or friends for the backend.
- Databases like MongoDB or Postgres.
- Infrastructure on AWS, GCP, or Azure.
The 2020s: Microservices, Serverless, and AI Everywhere
Today, we’re in the era of breaking things apart.
- Microservices: Instead of giant monolith apps, we build small services that each do one thing. More flexible, but also more complex.
- Serverless: AWS Lambda and friends let you deploy code without managing servers. Pay only for what you use.
- Frontends: React keeps evolving. TypeScript exploded. Frameworks like Next.js handle routing, rendering, and data fetching.
- Backends: Node.js still lives strong, but Go and Python play big roles.
- Databases: SQL, NoSQL, serverless databases — take your pick.
- AI: It’s everywhere — copilots helping us code, APIs powering search, personalization, and more.
Our current stacks — React with TypeScript, Go/Python backends, MongoDB, GitHub, AWS — make sense in this historical context. They’re the product of decades of iteration, experiments, and flame wars.
And in ten years? Today’s stack might look as dated as COBOL does now. That’s just the nature of tech: it reinvents itself.
If you’ve made it this far, congrats — you’ve leveled up your developer trivia skill tree. Next time someone mentions punched cards or JavaScript being built in 10 days, you’ll have the stories ready.
This was the first deep dive of The Stack Unpacked. Next up, we’ll tackle JavaScript — The Language That Runs the Web.
Until then — keep building, keep breaking, and remember: every stack has a story. You just unpacked one.
Top comments (0)