Facilitating the Spread of Knowledge and Innovation in Professional Software Development

Write for InfoQ


Choose your language

InfoQ Homepage News The Commoditization of Software Stack: How Application-First Cloud Services are Changing the Game

The Commoditization of Software Stack: How Application-First Cloud Services are Changing the Game

Cloud services are evolving, which influences how developers build distributed applications. At QCon London, Bilgin Ibryam, product manager at Diagrid, discussed the intersection of cloud-native technologies like Dapr with developer-focused cloud services.

Ibryam started with how to look at applications transformed from being monoliths to microservices and what is coming next. In addition, he will also talk about how infrastructure is evolving in the form of cloud services and how it is shaping the architecture.

The narrative during the talk was around different phases (time-line) of building applications in the pre-or early cloud era, compute-first cloud, and application-first cloud era from an infrastructure and application trends perspective.

Ibryam started discussing the early or pre-cloud era, which meant applications were monoliths. This era was before the cloud was mainstream, and there was nothing around microservices. Instead, developers had to use everything around the business logic ranging from asynchronous interactions like messaging to packaging and caching. Furthermore, there was a distinction between the application layer and the infrastructure managed by the two teams (Developers and Operations).

Next, Ilryam discussed the internal architecture following the pre-an early cloud era. There was a revival and renewed interest in application development after 2010, with a few major software developer trends that happened next and are still influential today. There are different ways to look at architecture through visualizing and describing them using the C4 model or 4+1 architectural model view. Ibryam takes a more straightforward approach with two levels: internal and external architecture. The internal application architecture is everything created by the developer and fully in his control, like different layers in the application, or as he puts it, everything that goes into a container image. From an Operational (Ops) view, it is a black box. The external application architecture is a collection of everything the application interacts with, like message brokers, databases, and even cloud services. The Ops makes it reliable, observable, and so on. With that in mind, he discussed some architectural design methods that impacted the development of monolithic applications, such as domain-driven design, hexagonal architecture, onion architecture, and clean architecture. 12-factor app and microservices principles followed these, leading to monolithic applications becoming almost anti-pattern.

After pre- and early cloud came the compute-first cloud, where the transition started from monolithic applications to microservices. Changes in the internal application architecture and the emergence of the cloud led to a split integration between the application and its infrastructure.

While discussing the compute-first, Ilbryam went into detail about the application’s internal architecture and compute provided by the cloud. It is a contract (integration bindings) between the application and the computer, whether a container, function, or serverless application. It occurs between APIs (operation calls such as resource demands, deployments, configurations, and metrics) on both sides. Operation teams are usually responsible for it.

Next, Ilbryam discussed how the external architecture for applications changed over time again with the cloud emerging in mind. Again, the concept of application bindings was discussed; however, now with cloud service on top of the application rather than the infrastructure beneath it, which is the developer’s responsibility. 

The integration bindings towards the cloud services can move into another layer like Distributed Application Runtime (Dapr). To compare Dapr in that respect, Ibryam mentions Google Cloud Event Arc, AWS EventBridge, and Azure Event Grid as Cloud-specific and Camel as Language Agnostic. Dapr is both.

Finally, Ibryam talked about the application-first cloud, where for instance, networking services are becoming more application-focused, and the birth of the integration cloud: a collection of managed services that are created for developers first.

The application-first ecosystem will have asynchronous bindings with event processing services like Azure Eventgrid, Stateful bindings with services like AWS Step Functions, synchronous bindings with services like Vercel Edge Middleware compute bindings with compute services like AWS ECS, Azure Container Apps, and Google Cloud Run. The communication will take place through APIs adhering to OpenAPI specifications

Lastly, Ibryam provided the key takeaways from his talk:

  • Focus on differentiating business logic and reusing undifferentiated commoditized capabilities.
  • Use open compute and open integration bindings based on de-facto standards enabling portability.
  • Portability is not about applications. It is about patterns, practices, tools, and people.

About the Author

Rate this Article