A blog post by Satnam Singh, former member of the Kubernetes team, caught my attention recently. Among other ideas, the post laments the lack of an abstraction layer isolating application developers from the low-level details of adapting their implementation to a particular deployment configuration. To my ears, this sounds like a textbook application for Model-Driven Engineering (MDE), a by now mature software development paradigm with a reasonable but not stellar level of industry adoption.

What really intrigued me was how the post ended up literally stating the definition of MDE in an effort to describe a desirable solution to the problem of cloud deployment. Here are some choice quotes, together with my translations to MDE-speak.

I think we should develop cloud computing applications by writing a program in a first class programming language like Go or Haskell that denotes the desired deployment of our system; specifying an executable model of the desired system rather than its explicit implementation.

In MDE, this would traditionally be understood as behavioral modeling, and accomplished via state machines and process languages such as UML Activity Diagrams or BPMN, rather than general-purpose programming languages. But the main idea remains: specify the behavior, not its implementation.

Using tools on a local computer, this code could then be analyzed for bugs in its functionality, formal techniques could scrutinize it for security issues and aspects of the behaviour of the desired system could be simulated.

Indeed, behavioral models can be formally analyzed and executed using an action language. The quality of tool support for these tasks may vary depending on modeling language, but these aspects of behavioral models are relatively well understood.

When we are ready we could run something other than a compiler on this code to “synthesize” the actual implementation that should be deployed.

In MDE terms, this would be called code generation. As the post goes on to describe the generation of deployment configuration specifications, this “synthesis” step could more accurately be described as a model-to-text (M2T) transformation. Luckily, there are several production-ready M2T tools out there, such as Acceleo and Xpand.

Alternatively, you could think of some other technique that tries to raise the abstraction level at which we design, develop and deploy cloud computing applications and close the semantic gap between what’s in the developer’s head and the low level nuts and bolts we have today for actually creating cloud computing applications.

My point is that people have thought of such techniques for decades. Some even claim that the history of software engineering is one of rising levels of abstraction. MDE is certainly not the first attempt – the fourth-generation programming languages (4GL) effort of the 80’s comes to mind here, but there were probably even earlier proposals for programming at the level of “what’s in the developer’s head” (a timeline of these would be really interesting).

Interestingly, the natural fit between cloud computing and MDE has already been identified by the research community. There are even annual workshops dedicated to this topic. Here’s hoping that this time around we don’t end up re-inventing our past in an effort to create the future, as so often seems to be the case in software engineering.