Java Was Almost a Funeral Pyre
Tim Lindholm was shivering. Not from the code — though he'd soon be sweating through a three-day rewrite that would keep an entire programming language from dying on stage — but from the brutally cold Minnesota winter. He was living in a tent, actually, before scoring an internship at Argonne National Laboratory that pulled him into computing. His real dream was to be a mathematician. "Computer science was for people who couldn't be real mathematicians," he said.
But that detour taught him something crucial: how to write to very high-quality virtual machines with garbage collection and embeddability, thanks to the lab's use of Prolog. The VM experience led him through Xerox PARC, then to Sun Microsystems in 1994 — where he'd walk into the worst possible moment.
Sun was about to gut his entire project. Lindholm had been there exactly one month, hired specifically to polish a virtual machine runtime for what would become Java. He'd spend months feeling like "dead meat" waiting for his own termination notice.
What he didn't know then: those twelve engineers who survived the layoffs — refugees in a bombed-out bunker, as he'd later describe them — would build something that runs on trillions of dollars in enterprise infrastructure. Java didn't arrive fully formed. It stumbled, nearly died, and got saved by people who refused to let it go.
That's the driving theme of The Java Story, Cult.Repo's new documentary that debuted on YouTube this past Friday. The film traces Java from its set-top box origins through the Microsoft antitrust war to OpenJDK, featuring interviews with creator James Gosling, senior Oracle Java architects Mark Reinhold and Brian Goetz, and Lindholm himself. It's the first product of Cult.Repo — short for Culture Repository — a production shop reborn when founder Emma Tracey bought the documentary arm back from New Work SE (formerly XING) after Honeypot.io's 2019 acquisition. If you've seen their docs on C++, Python, or React, you know the pedigree.
And it's a story worth telling, even if the language itself has become so ubiquitous we barely notice it anymore.
Read more about Java's origins in programming language history
From Set-Top Boxes to Almost Nothing
Sun Microsystems had built its fortune selling high-end workstations to engineers. But in 1994, the company wanted more — it wanted into devices outside the desktop market. So they created FirstPerson, an experimental "spin-in" subsidiary tasked with building software for set-top boxes. The prize was a bid from Time Warner to provide interactive video-on-demand infrastructure.
James Gosling wrote Oak — the language that would become Java — for this project. It was ambitious, ahead of its time in several ways, and completely misaligned with where the market was actually heading.
Then Silicon Graphics — late bidder, Sun rival commonly known as SGI — won the contract. The defeat hit hard. Sun laid off most of FirstPerson's staff, keeping only twelve engineers to continue working on Oak: Gosling, project manager Kim Polese, and a handful of others including Lindholm. The image is almost cinematic: engineers who'd been let go tossed their desks and gear into hallways.
The Time Warner project itself would struggle for a few years before the plug was finally pulled in 1997 — which didn't do the already-struggling SGI any financial favors. But at the time, Sun just took the defeat hard.
Lindholm felt like "dead meat" at the Sun office, just waiting to get laid off himself. He'd been there a month and wasn't overly invested in the set-top box. "I'll do whatever comes next," he recalled. Those who survived described themselves as refugees in a bombed-out bunker, huddled around a project that had no clear future.
The language that would eventually run on billions of devices was, at its lowest point, a ghost operation in a building that had already moved on without it.
The Web Saved Them
Serendipity, not strategy, pulled Oak back from the brink. One of the surviving engineers had been playing with Mosaic — the newly released browser that would define how people experienced the web — and suggested Oak should target the World Wide Web instead. This was a year before Windows 95 brought internet browsing to mainstream desktops.
The team built WebRunner, a Mosaic clone that could run animations written in Oak. It was essentially the precursor to Java applets, though nobody knew it yet.
Events accelerated fast after that. Oak was renamed Java in early 1995, reportedly as a nod to the engineering team's coffee consumption. "It took off like a friggin' rocket," Lindholm recalled. "We were all stressed."
An early wave of web developers was rapidly discovering the limits of HTML — after all, it's a markup language, not a programming one. Gosling and the crew had assembled a rough prototype, but making it actually work in production fell to Lindholm alongside Frank Yellin, a Lisp expert and fellow new hire. Their mandate: take Gosling's advanced concepts — threading, garbage collection — and make them function in the real world. They later co-authored the original JVM specification.
Threading was particularly treacherous territory in 1995. There were no libraries to borrow from. Lindholm knew relatively little about the concept himself, which made the coming crisis all the more terrifying.
Three Days Before the World Was Watching
Sun planned to introduce Java at the 1995 SunWorld convention — the precursor to JavaOne. The runtime was crashing badly.
After extensive debugging, Lindholm discovered the threading model was "fundamentally broken. It was totally screwed up," he said. The problem lay in how system interrupts interacted with the SPARC processor: interrupts were being issued while the processor was executing an instruction, which meant the system couldn't recover state flushed from memory. The result? The runtime would "die horribly" during a live demo.
Lindholm realized interrupts could only happen at specific points. So three days before the conference, he rewrote the entire threads package.
At SunWorld, CEO Scott McNealy took the stage to demonstrate Java. Lindholm sat in the audience, dreading the worst. The rewrite held. Java survived its debut.
This is the moment the documentary zeroes in on, and for good reason. You can trace Java's entire trajectory back to a single engineer working through the weekend, knowing that failure would be public and permanent. Most of us have had a Tuesday morning that felt like that. Lindholm just happened to be saving a language.
Explore the evolution of programming languages
Open Source Before the Term Mattered
Long before Eric Raymond made "open source" a household concept, Sun was already giving Java away. The company offered the binary runtime as a free download, but Lindholm was in charge of something even more radical: they gave away the source code to anyone who asked. Thousands did.
The documentary retells a story that the Java Internet domain was getting so much traffic — more than Sun.com itself — that the team ran a pirate T3 line into the office. Those were the days before cloud infrastructure made bandwidth a non-issue.
Lindholm viewed giving away the source as pragmatic career insurance. Should he ever get axed, perhaps another company would pick up the code and run with it. They also discovered that outsiders could fix bugs and extend the software to platforms Sun hadn't considered.
Richard Stallman came to visit, but he seemed "too radical" for Sun's leadership, Lindholm recalled. The company wouldn't officially release Java as open source for another decade.
Ironically enough, Java applets were only modestly adopted on the web. Other technologies — ColdFusion, Netscape's JavaScript project — ended up doing the heavy lifting for web programmers. But applets served as a gateway drug to Java's real impact: powering back-end servers. That's where the language found its true calling.
The Microsoft Antitrust War
Then Microsoft started paying attention. And by "paying attention," I mean they saw Java as an existential threat to Windows NT's dominance in the enterprise.
For today's younger IT professionals, it's hard to overstate how aggressive Microsoft was in the mid-90s. In 1996, they licensed Java for Windows — but then added proprietary APIs, declined to support others, and created J++, a version that deliberately broke cross-platform compatibility. Sun alleged Microsoft's changes were designed to lock developers into Windows-specific implementations.
The resulting legal battle dragged on for years, draining the Java development team's energy and diverting resources. "I spent days in deposition talking about this under oath," Lindholm recalled. "It was personal for us."
The disputes ended with Microsoft paying Sun nearly $2 billion through a series of settlements in 1997. It was one of the most significant antitrust outcomes in tech history, and it kept Java alive as a truly cross-platform technology.
The documentary doesn't shy away from this chapter. It's a reminder that even brilliant technology doesn't survive on merit alone — sometimes it takes a courtroom to protect it.
The Wild Ride Continues
The documentary doesn't stop at the antitrust settlements. It traces Java through the over-engineered era of J2EE and Java EE 5, the glimmer of hope provided by the Spring framework, Sun's implosion and subsequent acquisition by Oracle, and the flourishing of JVM languages following the release of OpenJDK.
Java continued to be a success for Sun, even as its chief business of selling SPARC-based Internet servers fizzled thanks to the influx of low-cost Linux x86 boxes. Lindholm noted that the Java team grew so large that it took over Sun's headquarters and eventually had to move into the old Apple headquarters.
But Lindholm's passion for Java evaporated by the early 2000s, swamped by the increasingly corporate environment. He left for Google, where he would spend the next 20 years until his retirement earlier this year.
Looking back to his early involvement, Lindholm admitted "it was kind of a random thing. You can never tell what parts of your life will end up being really significant for whatever reason."
As Java creator James Gosling said in the doc, "What excites me most about the future is the unknown. Lots of things happen, and mostly the interesting ones are the ones you could never predict." And that's really what makes The Java Story worth watching — not just for the history, but for the reminder that the technologies we take for granted today often came from people who had no idea what they were building when they started.