When we look to the future of applications and platforms, we need to keep an eye on the solutions of the past.
That is one of the main theses of Stephanos Bacon, Sr. Director of Portfolio Strategy at Red Hat, in this video from Red Hat Summit 2018, “Clouds Today, Serverless Tomorrow: Your Future Apps and Platforms”:
In order to understand the present situation around the many choices of languages and platforms a developer faces, Stephanos briefly walks through a 25 year year journey of enterprise software development. This journey is one of a “continuous-though-forward-moving cycle”.
This cycle looks back at itself to learn and adapt from the past while moving forward in response to changing market imperatives. While we may need new solutions, we also reach back in time to find seemingly old solutions that address new classes of problems.
With the idea of developers providing business value as code, the cycles of platforms, languages, and methods are driven by the market imperatives and constrained by what is technically and culturally possible in that moment.
In many ways over those 25 years, the arrow has flowed from monolithic applications to the service model, then leading into microservice architecture (MSA), and is now morphing into the function-as-a-service(FaaS)/serverless approach.
Yet if you look closely, you see a pulsing of the arrow, bringing forward old ideas for new problems. This means the arrow’s trajectory isn’t truly fixed in one direction.
When looking at the always-changing face of development, Stephanos offers some balancing perspectives to remember.
At the core are always going to be the fundamental questions and concerns of software development that are consistent over time, such as developer productivity and testing.
How we address these fundamental questions is going to be influenced by changes in technology, changes in market imperatives, and cultural and process changes that arise.
For example, the modern hybrid cloud is an answer to the problems of being locked into a vertically integrated software stack. If you write to the hybrid cloud, your applications will work across all the cloud providers. (There is a kinship to the adoption of the JVM and it’s write-once/run-anywhere approach.)
Ultimately, modern development’s movement into self-service isn’t going to reverse itself. Even your own private cloud is in competition with public cloud providers for the attention of your own developers.
In all of this, Stephanos has key architectural considerations to keep in mind:
- Be careful of impedance mismatches. While it can work to bring old code forward into a container or function-as-a-service environment without a rewrite, the older design for performance may simply not work as you need.
- Don’t lose track of key developer concerns, such as monitoring, debugging, tracing, and logging. All the watchwords still matter, so you must find ways to look into and visualize your older components in your new architecture.
- Even when otherwise feasible to have an application portable and available across the hybrid cloud, you may face technical, cultural, compliance, or other hurdles that make it too difficult.
What Stephanos describes as “the next step in developer productivity, back to not caring about what’s running under the code” with FaaS/serverless, may also mean making compromises in other areas. You may have to give up control, such as code size, runtime details, memory, scheduling, and so forth.
In response you may end up pulling even more tricks from the old playbooks — for example, breaking up into another microservice to gain more control of that service … but now you’ve added more complexity.
However, Stephanos reminds us that the rapid iteration around the development environment continues to provide more opportunities for new tools to solve the new-old problems. For example, Red Hat is looking at how Istio can provide the views and controls for increasingly complex MSA environments.