Subscribe
Share
Share
Embed
Containers can be a vital tool in the development of operations teams, allowing developers to build up skills in a technology that isn't specific to a particular type or workload, and to become more responsible for the life cycle of their applications. These portable containers can help organizations as they transition to the cloud by making workloads accessible across different technologies. However, the solution is still evolving, and some question if portable containers are destroying standards.
For this episode of the CCS Insight podcast, our chief of enterprise research, Bola Rotibi, was joined by IBM's Emily Jiang, Liberty Cloud Native Architect and Advocate, and Graham Charters, WebSphere and Liberty product manager. We also spoke to Clive Howard, chief technology officer at Huozhi, a provider of a humanitarian fintech platform. Clive is also an associate analyst at CCS Insight.
Our discussion unpacked the importance of containers in modern app development and how challenges are being addressed to help organizations make the move into the cloud. We also highlighted the role of APIs, and how they can serve to bring in other solutions and use other environments when containers aren't an applicable solution.
The podcast offers guidance on the needs of modern application development, discussing:
- How the industry is addressing API standards to increase developers' efficiency and allow them to reuse their skills.
- What value these standards present to businesses, and how technical leads can present this to their business counterparts thinking about investing in containers and APIs.
- How developers can use open standards to apply existing skills to different implementations, achieving standardization, consistency and portability across the board.
CCS Insight has produced a free report offering insight into how containers are affecting the standards landscape.
CCS Insight has produced a free report offering insight into how containers are affecting the standards landscape.
Creators & Guests
What is The CCS Insight Podcast?
Insightful audio from the global tech advisory firm.
Bola Rotibi:
Welcome to the CCS Insight podcast and the second of our podcast episodes with IBM. My name is Bola Rotibi and I'm the chief of enterprise research here at CCS Insight and your host for today's discussion on "Are Portable Containers Destroying Standards?". Joining me today from IBM are Emily Jiang, Liberty cloud-native architect and advocate, and Graham Charters, WebSphere and Liberty product manager. I'm also joined by Clive Howard, CTO at Huozhi, a provider of a humanitarian fintech platform. Clive is also an associate analyst with CCS Insight. Welcome to you all.
Emily Jiang:
Thank you for having us.
Graham Charters:
Hi, Bola. Thanks for having us.
Clive Howard:
Hi, Bola.
Bola Rotibi:
Excellent. Excellent. CCS Insight conducted a survey in 2021 to understand how the market is responding to containers. We received responses from more than 570 companies in Europe, the Middle East and Africa. Respondents were drawn from a wide range of organizations and industries and included business and technical roles. One of the key findings was how container technology can help address several challenges facing modern software development and deployment.
Graham, you have over 20 years in application and integration middleware R&D, and you help customers be successful with technology and evolving IBM's offering to meet the market's emerging needs. So, I ask you this question: how important is container technology to modern app development and workload operations?
Graham Charters:
Hi. So, I think, well, container technology is hugely important to modern app development and workload operations. To kind of highlight the importance and where the benefits are I'd like to kind of contrast the world of working with containers for application development and deployment.
First is the traditional world. So, in the in the traditional world, when I talk to customers, they talk about having an operations team, and that operations team is responsible for managing an application server runtime such as WebSphere and that operations team understand and automate all the operational aspects of that. And then on the development side, they have a separate development team that are responsible for developing the application, and when they finish creating that application, they throw it over the wall to the operations team and the operations team are responsible for managing it for the rest of its life. And in both cases the teams have skills specific either to the development side, specific to the APIs they use in developing the application, then on the operations side, they have skills specific to managing that server runtime.
Now in the container world — and I'm including container management, so Kubernetes, for example. In the container world, what we're seeing is that the operations teams are either evolving or the businesses are setting up platform teams that are responsible for the Kubernetes environment. So those teams are building up skills in a technology that is not specific to any particular one vendor, and it's not specific to any particular type of workload.
And then on the development side, the development teams are evolving to become DevOps or DevSecOps teams and they're responsible for doing their usual application development, but then they package that into a container that can be deployed to a number of different environments, either an on-prem Kubernetes platform or into cloud environments with Kubernetes-managed OpenShift and so on.
And so, the development teams, their jobs have evolved. They actually become, because they come this kind of become this DevOps team, they have a lot more skills they need to have in that group, in that team, and they're responsible for more of the lifecycle of the application. But what they create is in some respects portable across the different operational environments. And the operations teams, of course, they're building up, as I said, those generic skills.
Bola Rotibi:
Well, thank you very much, Graham, for that, actually. Emily, I'm sure you've got some to say to add to this. What would you add?
Emily Jiang:
Yeah, I want to because I'm from a developer background. In the past, when you do the application development and then a test or raise a bug an often phrase you will hear is "oh, but it works on my machine!". So, there's a ton of technologies, and you should build ones to run everywhere.
Bola Rotibi:
So, that brings a nice little you know sort of insight into the development side, actually. And I'd like to speak to Clive on this one because you must come across dealing with containers in your experience in the platform that you're building for your team. Can you talk to the importance that you see containers having in, you know, developing modern applications?
Clive Howard:
Sure, thanks, Bola. Yes, we have used containers. We do have certain workloads running in containers. I think containers certainly have an important role to play at this moment in time as organizations go through this movement to the cloud. It's not easy, cloud is hard, and getting into the cloud is difficult, especially if you're looking at perhaps legacy workloads, but even trying to build your first cloud workloads, I think technology like containers is incredibly helpful for the reasons that, you know, we've already heard about.
I think that they do have challenges, you know, they can be difficult. Those issues, those challenges are being addressed; people are trying to make some of that easier. And I think, you know, that will definitely help organizations to embrace containers more. And we'll probably see, we'll continue to see increased workloads running in containers. I think, though, that containers are not going to be the answer for everything. I think there's still a place for other technologies, both pre-cloud and more cloud-native technologies.
So, I think people need to look at containers for the value that they can bring in terms of a particular solution that they're trying to build, they're trying to deploy, but also looking at other options that are out there and seeing, you know, where those can perhaps be used for certain solutions as well.
So, yes, they are definitely, definitely an important part of the current development landscape. And I think they will continue to be, and I think the work that's being done by people like IBM around this is important in enabling more people to be able to leverage that value.
Bola Rotibi:
Well, one of the things, actually, that we found in the study that we did was — and all three of you have sort of mentioned it and alluded to it — was actually when we went out to the market, one of the big things was how much people saw containers being a value for portability and consistency, especially across lots of different technologies and lots of different environments, which is what you, Graham, talked about; Emily, you mentioned from a developer point of view; and Clive, you've talked about the value from that point of view.
So, if containers are all about portability, does that make application programming interfaces, APIs, it doesn't matter which APIs, no longer relevant? Graham, I'd like to come back to you.
Graham Charters:
So, I think we need to look at what roles APIs serve. APIs, I guess their first role is really to kind of make it easier for you to write applications. They provide functionality or capabilities or higher-level abstractions of things so that you don't have to do all the hard work associated with those things. For example, transactions or security or component models for writing your applications. If you had to write all of those things from scratch based on Java SE, for example, you'd spend probably 95% of your time writing all the kind of low-level things just to get to the point where you could write some business logic.
So that's the kind of first role of APIs. But I think the second role of APIs, if you think about the applications that you write and the amount of investment that businesses put into writing applications, you reuse a lot of things: libraries, runtimes and so on, such as the Liberty runtime. And because you're investing a lot in creating that code, your application code, you want to make sure that your investment is protected.
So, portability is still very important when it comes to APIs because you don't want all that investment that you've put into your application development to become irrelevant if, for example, what you were building on is no longer a maintained or supported technology. So, APIs accelerate your development, but they're also an opportunity to insulate yourself from underlying technology choices or underlying vendor choices.
Bola Rotibi:
Well, that actually talks very much to the point that Clive was actually talking about, the fact that, in many respects, while containers, you know, you provided a fantastic example in terms of how APIs are still really important, but also in the fact that you may not always use containers and so APIs serve to sort of help bring in other technologies or use other environments, so, there is a place for them.
So, Emily, you are known as a Java Champion and a well-known international conference speaker, a book author and a MicroProfile guru and technical lead in MicroProfile specifications releases — quite a mouthful, but amazing experience. So, I'm going to put my third question to you, which is what is the industry doing around API standards to address modern application needs and how does this align with Java technology innovations?
Emily Jiang:
Yeah, this is a great question. It is very important to have these API standards to increase developers' efficiency. So basically, once we have these API standards, I can develop applications, so that I can use many applications and reuse my skills. And then if I change jobs and then the community adopts an API standard, I can just reuse my skills to be very efficient. So, basically I don't need to relearn things, but I can do the most important things, which is to help the business. Luckily, we have Jakarta EE and MicroProfile. This, as Bola says, is a cloud-native application programming model. So basically, like MicroProfile, we have a config, fault tolerance to help create a resilient application, and also we have a JWT, MicroProfile has JWT Authentication to secure applications, and also we have MicroProfile metrics to add to the application metrics so that you can add other data operations and monitor these applications and then take some precautions if something is going to go wrong.
Bola Rotibi:
And this must be really kind of — once again for you, Clive, as a practitioner — this must be really kind of important when you think about developers coming on and being employed by organization to have these standards so that it kind of allows a certain level of transferable skills, as Emily did point out.
Clive Howard:
Yes, absolutely. Yes, I would definitely agree with what the point Emily was making. I think both in terms of bringing on new developers — you know, you want them to be able to come in and start creating value for the business as soon as possible. And so, you know, the use of standards helps with that because they can look at something and instantly think, "okay, yes, I know what this is doing and it has works, I know how to do something with this", which is always super useful, especially as people talk about "projects that become products", and I think what they mean is things are, you know, workloads are in a constant state of evolution. And so, you're going to have developers coming and going perhaps more than when maybe you had a development team that was on a specific workload that was a very kind of closed thing, and they knew everything about how it works and that was fine because they were the people that worked on it and it kind of just sat alone and did what it was supposed to do. I think now you've got developers coming and going a bit more, it's not quite the same.
And also, they're not quite as closed solutions anymore as has already been mentioned. You've got much more distributed-type solutions where you know you're building something that someone else is going to leverage in their application and then someone else is using a part of their application, and maybe you're using somebody else's application through various sort of APIs or other interfaces.
And so, you want, you know, again, a standard so that you can make sure that all of that can kind of knit together and you minimize risk with regards to doing that. So, I think there's kind of two reasons there really why I think standards are incredibly helpful to a development organization.
Bola Rotibi:
Well, that's brilliant because actually, basically I think we've answered the conundrum. We put at the beginning of this and the title of our podcast, are portable containers destroying standards? And the answer is a definite no. They clearly aren't, they're actually augmenting and working side-by-side. So, my last question: Emily, could you tell us what value this all presents to the business and how should the technical leads present this to their business counterparts as they think about investing their time in containers and APIs?
Emily Jiang:
Yeah, this has great value for the business. Basically, I feel like the kind of IT companies interested in this area, they should all come together to work together, not reinvent the wheel, right? So basically, I work closely with Red Hat and Tomitribe and Microsoft and others to evolve these standards so that we don't do the closed door, we reinvent the wheel, the leg has a socket, for example, we need the converge to carry all the convergence to the different countries to plug in.
So, with this API standard we come together and work on the common thing so that the developers, they don't need to converge. So, this is, again, it's good for the business, good for the consumer and they increase the efficiency for both the business owners and also the business consumers.
So, one thing I want to encourage the technical leaders to come together on and join us and work on this standard. And also, Open Liberty is a strong supporter for both MicroProfile and Jakarta EE. And also log on to the openliberty.io — try out how we implement it. It's helpful to see more people get involved in the API standard work.
Bola Rotibi:
Oh, that's fantastic, Emily. A really good call to action to our listeners and in terms of the benefits that the API standards and containers provide for the business. Graham, I just want to give you an opportunity to have any last words, any last inputs to that.
Graham Charters:
I think it's quite well understood now around the role of portable containers and how that makes you independent of platform environments so you can deploy your containers in various different clouds or on-prem container platforms. But don't lose sight of the investment you make in developing the applications that run inside your containers, and think about how you can protect that investment through the choice of the technologies you're using to do those implementations.
And this is where the open standards really excel. I'm not sure Emily mentioned it, but with the MicroProfile standards, for example, I think there's somewhere in the region of 14 different implementations and Jakarta EE is similar. So, you've got that protection, the fact that you can take your application code, take your skills and apply those to different vendor implementations.
Bola Rotibi:
And that's a really good point, actually, in terms of that standardization, that consistency and, you know, leveraging existing skills, but also ensuring that you have that level of portability right across the board, whether it's through containers or through APIs.
I'd like to say a thank you to Emily, Graham and Clive for what I think it's been a really great conversation. And I think we definitely proved that they're not destroying standards, portable containers are not destroying standards, so that's a good thing and they're working in collaboration.
So, for our audience, please do make sure you tune in to our first podcast that talks about Java's Future in the Cloud. But until then, until the next one we have, I'd like to say thank you very much to everyone and goodbye until our next discussion. So goodbye, everyone.
Graham Charters, Emily Liang and Clive Howard:
Bye, bye. Goodbye.