The End of Tribalism in Software
How many times in the software industry have you heard developers fight over which programming language is better? How many times have you heard about that one pattern that will fix all of our problems moving forward?
We as an industry are very tribal when it comes to our technologies, programming languages and architectural patterns — it’s either our pattern or theirs; it’s either my language or yours. For a long time, it’s always been us vs. them. Finally, this is coming to an end.
The end of software tribalism and the beginning of a very well-accepted hybrid world is a transformation that has been in the works for the past 30 years, but it’s only becoming a reality in its latest form since five years ago, with the explosion of new software ecosystems and the cultural revolution of enterprise open source adoption. This hybrid world is a new era, where the pragmatism and availability of multiple ecosystems finally give us a wide variety of options to build our software and design our architectures in an unprecedented way. It’s a multiprogramming language, multiplatform and multi-architecture world today. It’s a revolution — not just technological but also organizational. It’s the end of tribalism.
A New, Hybrid World
The vision of a hybrid world, where interfaces are more important than the implementations, is not novel. Looking back at the history of software architectures, we can find its roots in the 1990s when CORBA (Common Object Request Broker Architecture) was first widely adopted in the enterprise. Many of today’s modern architectures borrow ideas from that world — primarily the ideas of distributed, decoupled, remote objects. This sounds a lot like microservices, which is really what triggered the end of tribalism in software, driven by a bigger underlying trend: modern open source.
Docker (2013) and Kubernetes (2014) started a new era for distributed and decoupled systems, and therefore, for APIs. However, the foundational principles of microservices have deep roots in the past.
Traditional open source as we know it is determined by three main pillars: the community, the ecosystem and user adoption. Taking this one step further, modern open source has a fourth pillar: enterprise adoption. Examples of modern open source products are Docker, Kubernetes, Elasticsearch, Kafka, Kong and so on.
Modern open source embraces a bottom-up adoption motion as opposed to traditional top-down enterprise software
Modern open source technologies are driving a technological, cultural and organizational revolution in the Industry, leading to the end of tribalism and the beginning of a new, hybrid world.
“Open source plays a different role for different players of the ecosystem, but the best one is empowering developers. In a typical company, developers didn’t make a lot of software decisions , but that has changed in a big way.” — Neha Narkhede, co-creator of Kafka.
This change is reflected through three main trends:
1) Different programming languages will coexist.
What matters is the interface — the API. Technologies like gRPC, Apache Thrift and traditional HTTP APIs have been leading this trend. We are increasingly moving into a world where different programming languages will coexist in the same architecture and communicate via an API (or event) over the network. Microservices helped with this notion by freeing the developer from the programming language of choice and allowing them to experiment. As a result, more developers will be proficient in a larger number of programming languages, and their ecosystem adoption will grow as a result.
2) Different architectures will coexist.
Every architectural trend, including microservices and serverless, claims to be the best solution for every problem in the world. When the only thing you have is a hammer, everything looks like a nail. Likewise, with programming languages, the industry is returning to a more pragmatic approach. We are understanding the need for hybrid architectural patterns for our systems, where monolith, microservices and serverless systems will co-exist together as a response to particular technological — or business — challenges.
It’s not going to be one architecture or another — it’s going to be all of them. Even more, we are going to build software in a way that allows us to move from one architectural pattern to another relatively easily whenever the requirement arises.
3) Different infrastructures will coexist.
A quest for running software on the latest and greatest infrastructure will always be there, and so will the need to consolidate multiple infrastructures into one. Realistically, the time it takes to migrate large systems over to newer infrastructures will always be slower than the innovation time it takes to discover better ways of doing things. As such, for most large organizations running on hybrid platforms, it’s going to be the de facto reality.
It’s going to be containers and virtual machines, perhaps running on multiple clouds even. When over time the cost of switching gets lowered, instead of consolidation, we might actually see the opposite happening — likewise for programming languages, clouds become a commodity, and as long as we have the right interface in place for cross-cloud communication, departments and teams will use the right cloud offering the most appropriate set of services for their use case.
The Cloud Wars
We cannot talk about the end of tribalism without connecting it with the “Cloud Wars” between Amazon, Microsoft and Google. The end of tribalism doesn’t happen coincidentally with the Cloud Wars. In fact, they are a major driver.
To acquire a larger cloud customer base and prevent incumbent players from having a quasi-monopoly in cloud infrastructure, Google has been contributing to the open source community and pushing for commoditization of infrastructures with the open Kubernetes platform by heavily investing in a new, emerging ecosystem sponsored by CNCF. Commoditization of infrastructures and thought leadership in the developer’s mindset — in a world where developers have more power in determining where production workloads should run — in turn, allows a cloud challenger like Google to attract more customers from more established cloud vendors.
Developers and their mindset are becoming more critical to any modern open source player because ultimately it’s what drives enterprise adoption. Like Al Ries and Jack Trout would say, it’s the “battle for your mind.”
CNCF Landscape (Source: CNCF). Click to “embiggen.”
Enterprise organizations entering the new world of modern open source, made by large emerging technologies and ecosystems, will have to adapt their process and organizational structure to reflect the reality that business units and teams are making critical technology decisions not always backed by “Central IT,” which traditionally despises a hybrid organization because of the overhead. They’ll need to find technology solutions for all of these moving parts, hybrid architectures and technologies that can help manage this new complexity.
We are seeing a bottom-up approach to central IT, where technology adoption is not dictated by a “center of excellence” anymore (top-down) but rather where central IT optimizes and centralizes technology decisions that have already been made by the underlying business units and teams, making them into more manageable centralized clusters. This is fundamentally happening because the teams — that are closer to the business and to the customers — have to react and adapt to new business requirements at a faster pace than the Central IT can adapt and embrace to new technologies.
Therefore, more business value will be delivered with control planes that can help get a sense of the technology running in production and the organizational interdependencies between all the parts involved, and can help over time to consolidate the most common technologies adopted by individual teams and business units into centralized clusters.
So, welcome to the hybrid world driven by modern open source, where different programming languages, architectures and platforms run together alongside each other to achieve very specific business goals that every individual team is pursuing. In a world where developers get smarter thanks to the emergence of open and self-service ecosystems, where interfaces become the primary means of communication across different technical and perhaps even organizational boundaries, it becomes the quest to find the best tool for the job and less a matter of “us vs. them.”
In essence, software is eating software-tribalism.
Feature image by Christian Wiediger on Unsplash.