The Trinity: How Three Languages Built the Web
My son came to me last month with a business problem. He's been detailing cars for a couple of years now, building a client base through word of mouth and Instagram. But he wanted a website. Something professional. Somewhere to show his work, list his services, let people book appointments.
"I looked into it," he said, "but there's like... three different things? HTML and CSS and JavaScript? Why can't there just be one?"
I started to explain, and then I realized: he already knew the answer. He just didn't know he knew it.
"What's under a car?" I asked.
He looked at me like I'd lost the plot.
"Humor me. What holds everything together on that '72 Bronco you're always sending me videos of?"
"The frame," he said. "Body-on-frame. That's why those old trucks are so easy to restore. You can pull the whole body off and..."
He stopped. I watched it click.
The Frame
Classic cars (and most trucks still) use body-on-frame construction. There's a steel frame underneath, and the body bolts onto it. The frame is the structure. It defines where the wheels attach, where the engine sits, where the suspension mounts. It's not pretty. Nobody looks at a bare frame and says wow. But without it, you don't have a car. You have a pile of parts.
As it turns out, every page on the web (and most of the screens in the apps on your phone) sits on a framework too. It was developed by a researcher in Europe right around the time yours truly was graduating high school.
In 1989, a physicist named Tim Berners-Lee was working at CERN in Switzerland, where researchers couldn't easily share documents with each other. Finding what you needed meant knowing who had it and asking directly. His solution: what if documents could contain links to other documents? What if clicking a word could take you somewhere else? He called it hypertext, and to make it work, he needed a way to describe the structure of a document.
He called it HTML: HyperText Markup Language.
HTML is deceptively simple. It uses "tags" to describe what things are. A heading gets <h1> tags. A paragraph sits between <p> tags. A link uses <a>. That's the whole idea. No colors, no fonts, no animations. Just structure.
<h1>Pro Detail by Danny</h1>
<p>Mobile car detailing in Portland. <a href="booking.html">Book now</a>.</p>
When you load a webpage, your browser reads the HTML first. It builds a mental model of the document: here's a heading, here's some text, here's a link to another page.
My son nodded slowly. "Okay. So HTML is the frame. What's the body?"
The Body
A bare frame isn't much to look at. What people actually see, what makes a '65 Mustang (KB43VER) look like a Mustang and not an iconic '69 Camaro, is the body. The sheet metal. The curves. The paint. Two cars can share nearly identical frames and look nothing alike.
The early web had the same problem, just in reverse: everything looked the same because there was no real way to make it look different. Grey backgrounds. Times New Roman. Blue underlined links that turned purple after you clicked them. Maybe a visitor counter at the bottom and an "under construction" GIF if you were feeling fancy.
By the mid-1990s, the web was growing faster than anyone expected. Businesses wanted websites. Artists wanted websites. Everyone wanted websites. And they all wanted them to look different.
But HTML was never designed for aesthetics. So people started hacking. Font tags everywhere. Color attributes jammed into every element. Nested tables (tables inside tables inside tables) just to get two columns side by side. Every page was a Frankenstein of inline styling. Want to change your company's blue to a slightly different blue? Edit every single page.
By hand.
In 1996, the web community introduced CSS: Cascading Style Sheets.
CSS handles one job: how things look. Colors, fonts, spacing, layout, shadows, animations. Anything visual belongs to CSS. The same HTML structure can look completely different depending on which stylesheet you apply.
h1 {
color: #1a1a2e;
font-family: Georgia, serif;
}
p {
line-height: 1.8;
max-width: 650px;
}
That word "cascading" is clever. Styles layer and inherit. A paragraph might get its font from a rule that applies to the whole page, but have its own specific color. This hierarchy lets massive websites maintain consistent styling without repeating themselves endlessly.
"So if I want to rebrand," my son said, "I just change the CSS?"
Exactly. Same frame. New body, new paint, new everything the eye can see. Add a spoiler. Delete the side mirrors. Swap the hood for something with a scoop. Anything static is fair game. You don't have to touch the frame at all.
CSS separated content from presentation. Writers could focus on words. Designers could focus on aesthetics. And when a company wanted to update their look? Change one file, every page updates automatically.
Structure and style. Frame and body. But a car that can't move isn't much of a car.
The Engine
"Okay," my son said. "So I've got the frame, and I've got the body. What makes it actually do things?"
I asked him what happens when you turn the key on that Bronco.
"Starter engages the flywheel, engine turns over, fuel and spark, combustion..." He caught himself. "Right. The engine."
The early web didn't have one. Pages just sat there.
In 1995, Netscape dominated the browser market, and they had a problem. Web pages were static. You could click links to move between pages, but nothing on the page itself could respond to you. Forms couldn't validate input before submitting. Menus couldn't expand or collapse. Content couldn't update without reloading everything.
They needed something that could respond to input. A programming language that could run inside the browser. One engineer was given ten days to create it.
Ten days to design a language that would eventually run on nearly every computing device on Earth. The rushed timeline shows. Ask any developer why === exists and watch them sigh deeply into their coffee. But it worked. Brendan Eich shipped it, mass adoption followed, and the rest is mass hysteria.
JavaScript became the behavior layer of the web. It responds to clicks. It validates forms. It animates elements. It fetches new data without reloading the page. It eventually powered applications as complex as Google Docs and Spotify's web player.
document.querySelector('.menu-button').addEventListener('click', function() {
document.querySelector('.menu').classList.toggle('open');
});
That snippet listens for a click, then toggles a menu open or closed. Simple, but it's the same fundamental concept behind every interactive feature you've ever used on the web.
The engine, the drivetrain, the suspension. Everything dynamic.
Three Parts, One Machine
Here's the mental model:
HTML is the frame. What exists, where things connect, structure without opinion.
CSS is the body and paint. What people see, presentation without functionality.
JavaScript is the unapologetic burnout when you finish the build.
When you visit my son's site, your browser downloads the HTML first. That HTML includes the CSS and JavaScript, either directly or as links, and holds it all together. His list of services, the photos of finished details, the booking form, the brand colors and fonts, the button that submits a request. Three languages, one page.
The Unibody Era
"But here's the thing," I said. "Modern cars don't really work that way anymore, do they?"
My son shook his head. "Unibody. Frame and body are one piece now. Lighter, more rigid, but you can't separate them."
Same thing happened to the web.
Those three languages, HTML, CSS, and JavaScript, were invented over 30 years ago. The core technologies that power every website, every web application, every browser-based tool you use today are older than many of the people building with them.
They've evolved, of course. HTML5, CSS3, ES6, and so on. But the fundamentals remain. What's changed is how we build with them. Modern frameworks like React, Vue, and Svelte are like unibody construction: structure, style, and behavior live together in components instead of separate files.
More efficient. More powerful. But harder to see where one ends and another begins.
Frameworks come and go. Build tools get fashionable and then fade. But underneath, the trinity endures. Every React component, every Vue template, every Svelte file eventually compiles down to the same three languages that Tim Berners-Lee and Brendan Eich and the CSS working group gave us decades ago.
Finish Line
My son built his website. It took a weekend. He used a modern framework because that's what the tutorials taught, and he had help from yet another evolution: AI. When he showed me the result and explained his process, I realized I wanted to understand this new tool the way I understood the old ones.
So I wrote this piece the same way he built his site. 😉
Next time: What actually happens when you type a URL and press Enter? We'll trace the journey of a request from your keyboard to a server on the other side of the world and back again. Usually in under a second. Usually.