IBM recently announced new developer initiatives to make life easier for software engineers working with the latest advances such as Kubernetes, blockchain, AI and bots. IBM summarizes these offering on its popular developerWorks blog with details on  IBM Code Patterns + Bot Asset Exchange here and more on the IBM Bot Asset Exchange blog here. To get more context around the news and to get IBM's perspective for VMblog readers writing applications and services to take advantage of new technologies, I caught up with Angel Diaz, vice president, developer technology and advocacy, IBM.

VMblog:  We're at a point where the cloud is obviously a very mature concept for developers.  What do you think are the more nuanced shifts that are going on today in terms of how developers are creating applications for cloud-native deployment?

Angel Diaz:  From a developer perspective, the cloud journey started with the democratization of infrastructure, and obsessing about compute, network, and provisioning of virtual machines. Now we're at the second frontier of cloud applications. When developers are thinking about building new applications for the cloud today, they aren't just thinking about compute, storage and networking -- they're evaluating three new programming models for cloud native applications. 

They're thinking -- how can I build my applications in one of three ways? Is it (1) an event-driven application; in other words, serverless or function-oriented?  Is it (2) a 12-factor app, using something like Cloud Foundry? Or is it (3) more of a microservices based application with Kubernetes and containers? These are three different categories that developers writing to the cloud are starting to understand as application programming models. So I think in 2018 you'll start to see a mass of developers focus on above the compute, network and storage layer, and focus more on those three paradigms, and even when to mix and match them. That's where developers' heads are going in 2018.

VMblog:  What are the circumstances that IBM sees leading developers to choose one of these three over another?

Diaz:  We're seeing event-driven architectures take off is where there are lots of triggers and applications that need to respond with a rapid set of actions. That's when an event-driven approach is a good one. A good category of application that benefits from event-driven is IoT, where you have tens of thousands of events occurring every second, that need some quick action. They are also popular when you are trying to bring together large chunks of applications that fit in a distributed and heterogenous environment, with different cloud vendors and infrastructures--and you want to tie into an event-chain.

With 12 Factor / Cloud Foundry type applications- the huge benefit around building an application around CloudFoundry is that the platform takes care of all of the complexity of setting up and provisioning your environment. You can focus on your code, and not so much on how to set up your database, how to make a security connection and all those things you do that take a lot of time. The whole model around Cloud Foundry is speed and iteration and embedding DevOps into the app itself. This model is really well-suited for when you want to focus on code first, and not configuration.

The microservices model is well suited for when you want a huge amount of repeatability and you want to build a more transactionally robust application. You're building applications within containers, these containers then can scale and be provisioned repeatedly across geographies with a certain SLA in place, and they can span on premise and off premise (all of these can span public and private cloud). When you're trying to approach application development for more transactional type applications that need to be more persistent - that's where I think these container-based and microservices-based models thrive.

VMblog:  But you've pointed out that the beauty of these patterns is that they can be mixed and matched?

Diaz:  Exactly. No application is an island.

Really the key point about these cloud-native models is that they can co-exist. Why is that important? Because if an application you build is sophisticated, one model doesn't fit everything you're trying to do - so now it's becoming much easier to build of the application using event-driven infrastructure, part of the application using more microservices and transactional business logic, and part of the application built as a 12-factor app. And then you can work together through APIs creating connected applications with those three models.

What you're starting to see now is that the way the actual run times are being built - it's almost like Russian Dolls now. If you look at Cloud Foundry, it's basing itself on top of containers. If you look at what's happening around serverless with OpenWhisk, the way the endpoints get started and stopped quickly are using containers.  That tells you there's a convergence of the run-time and how these three models are being built and offered to developers, which makes it easier to mix and match application models.

VMblog:  Explain the newly-launched Code Patterns in IBM Cloud.  What are you unlocking for developers who are looking at these three models?

Diaz:  IBM Cloud is the first cloud to expose a higher level of abstraction in the form of what we are calling IBM Code Patterns. The rise of open source, of containers, and of various enabling frameworks are really what have made possible all of these new deployment models. What we observed is that there are so many steps for developers weeding through code bases and documentation to stand up what amount to very common patterns.

So we launched 120 Code Patterns that are heavily curated packages of code, one-click GitHub repos, documentation and resources that address some of the most-used areas of development across these three cloud deployment patterns - from AI to blockchain to IoT.  We give the cloud-native developer a huge headstart on many common use cases, so that you don't have to start with raw OSS. And of course a lot of the enterprise-readiness that you would otherwise need to build yourself. Take something as baseline as container-security -- if you are using raw OSS and stitching all these patterns together yourself, you have this open ended question around security. If you use IBM Cloud and our Code Patterns -- containers are not only pervasive to many of the patterns, but IBM Cloud automatically scans all of your provisioned containers for security vulnerabilities.

##