In 2016 I wrote that “cloud convenience is killing the open source database.” It didn’t. Instead, as I noted more recently, open source has remained relevant even as cloud companies seek to make it easier to manage. That said, there’s reason to believe that open source matters in a very different way than some of its most ardent defenders believe.
Convenience isn’t the only thing that developers care about, as RedMonk’s Stephen O’Grady has stressed, but “for developers, convenience trumps most other technology characteristics.” Yes, open source is included in “most other technology characteristics.”
Losing the convenience war
Don’t get me wrong: All things being equal, developers will prefer open over closed. But in the cloud era, the place software falls on the open source purity spectrum isn’t developers’ biggest concern. If we’re going to be brutally honest, it’s always been that way. There’s a reason Microsoft Office has hundreds of millions of users; why Oracle has topped the database charts for decades (though this is changing). Open source has been a huge movement in software that dramatically changed how we think about software.
But it’s not the only thing.
This thought jumped out at me while listening to MongoDB’s fourth-quarter earnings call. (Disclosure: I work for MongoDB.) At the tail end of the call, one analyst asked about users of Community (a free and open version of MongoDB) turning into paying customers of Atlas (a fully managed cloud service). The company’s CFO/COO, Michael Gordon, said something that struck me: “Atlas self-serve, whether it’s free tiered or paid, it’s sort of the modern, more contemporary version of downloading Community Server and managing it yourself.”
Put another way, developers are turning to free-to-use managed cloud services in much the same way that they once downloaded free-to-use open source software. But it’s critical to point out that now, as then, the focus for most of these developers isn’t freedom—not in the sense that many free and open source (FOSS) advocates imagine. Developers are not focused on software freedom (and never really have been). They just want the convenience of using the software without having to get approval from Finance, Legal, etc. They have work to do and are trying to get it done with as few roadblocks as possible.
In other words, they want “free” as in “freedom to build in the most convenient way.”
Increasingly, that “most convenient way” is cloud. As Tim O’Reilly once noted, “There’s a pragmatic open and there’s an ideological open. And the pragmatic open is that it’s available.” Meaning? “It’s available in a timely way, in a non-preferential way, so that some people don’t get better access than others.” He continues, “When the cost is low enough, it does, in fact, create many of the same conditions as a commons.”
Hence, it’s just as true today as it was back when I wrote about it in 2009, that the more we fetishize open source as licensing and don’t look to the primary reasons mainstream developers embrace it, we’re going to lose the plot. Yes, licenses matter, but they don’t matter enough to spill copious quantities of digital ink trying to determine how many OSI-approved licenses can dance on the head of a pin when developers are most concerned with convenience.
So, how do we translate open source convenience to a cloud era in ways that developers actually care about?
Making open source convenient in cloud
One way that increasingly resonates is in the interplay between open source and multicloud. Though I’d written about it before, it was a more recent conversation with Craig Kerstiens, head of product at Crunchy Data (and an active PostgreSQL community member), that made the combination of open source and multicloud deeply real for me.
Kerstiens makes the argument that for multicloud to work, developers need to build “with best-in-class but open technologies like PostgreSQL, MongoDB, or Redis.” The point isn’t which technologies, but rather the idea that such technologies can run across all the different cloud, data center, or laptop environments a developer might wish for.
These don’t even need to be open source, per se, but a developer must be able to run them in their most vanilla format so as to make the application portable across clouds. By vanilla Kerstiens is alluding to things like PostgreSQL: The version you can download resembles but loses fidelity with the managed PostgreSQL services some of the cloud providers run (because they’ve added patches and other performance improvements that they don’t contribute to upstream PostgreSQL).
“The people I see having [multicloud] success choose those battle-tested open technologies and choose the vanilla ones, not the versions with the added special magic sauce,” Kerstiens told me. He estimated that this approach would work for upwards of 90% of enterprise workloads. That’s huge.
Another big way that open source applies is related to this first point. Given how different each cloud is—even in the areas of so-called commodities like storage, compute, etc.—open source provides a “lingua franca” of sorts that developers can carry with them between clouds. As I’ve written, while clouds may differ in how they implement PostgreSQL, for example, there’s enough commonality that a developer who knows PostgreSQL can be productive with AWS, Google Cloud, or Microsoft Azure. Kerstiens says, “As important as it may be for developers to know the intricacies of a particular cloud vendor, many open source technologies (Kubernetes, Linux, PostgreSQL, etc.) give developers skills that transfer between the clouds.”
Cloud perfects many of the reasons developers first embraced open source. This doesn’t mean that cloud renders open source obsolete. Not even close. But it does mean that FOSS advocates would do well to pay attention to the silent majority of developers who don’t waste their time on Twitter and instead look to cloud (and open source) to get real work done across clouds.