 noon wherever you are, and it is my great pleasure to introduce Mark. Mark, you are not only my boss, you are also the senior director of technical marketing in our application developer and services business unit, and you are basically responsible for everything I do during the days and also you and your team curate a ton of patterns around cloud native application architectures, and this is exactly the talk you're giving today, so take it away. Thank you so much for being here. Thank you so much, and I'm really excited to be here because this is one of my favorite topics. It's really about trying to make developers more effective wherever they are and whatever type of role they have. So maybe before I talk about red hat patterns, maybe I'd like to start off just providing some context when it comes to patterns. What do you think about when it comes to patterns? What does the word conjure up in your mind? And I think for a lot of people, if you say patterns, you'll think, oh, yeah, a pattern. That's like a piece of fabric or a large roll of sheet with a repeated motif, and yeah, that's a pattern. I recognize that. What I'd like to do is to share a different type of pattern, which is closer to what we'll be talking about. This type of pattern is more of one, it's a pattern set, and if you combine this pattern set, it allows you to assemble a piece of clothing, for example, a shirt. So that's great. And you may ask, well, why bother with this? Because you could always have had a seamstress, and a seamstress is so expert, and a seamstress could come up with a wonderful shirt. But for a seamstress, that requires a lot of time, a lot of effort, and a lot of background training for the seamstress. In short, it's a very artisanal approach. What I'd like to do is to take us on the path on how we can move beyond that artisanal approach. And once you start establishing patterns, that gives you the ability to take this pattern and repeat it. You can scale out, you can make the same shirt again, and again, and again. You can set up an assembly line to churn these out in mass production. You can swap out the actual graphics that are imprinted on each piece of fabric. So you have a shirt in different colors, different pattern styles. All of this is enabled by taking an artisanal approach to creating pieces of clothing, and taking a pattern-based approach. It helps us get more maturity, and it gives customers more choice and better quality. We see this evolution happening not only in the clothing industry, but we see this in industry after industry. It's a very common path of evolution. Let's take a look at one more example. Let's look at automobiles. So I guess none of you were around when the first automobile came out, so that was a real work of craftsmanship. Each of the original automobiles were created piece by piece, assembled from unique parts. In many cases, they even had to create the very machinery to make these pieces. So that really was an artisanal approach at an extreme. Then came along the assembly line, and Henry Ford was the pioneer of this movement. The assembly line gave us mass production, and through mass production, price points came down dramatically, and automobiles became accessible to more and more people in the population. One of the drawbacks, of course, was Henry Ford's famous quote that you can have any color as long as it's black. So that wasn't the pinnacle of the evolution of the auto industry. Things moved forward, and the industry began to mature. The next step, it began to form into different groups of modular components that would be combined together to create the full car. And that modularity allowed the different subsystem teams to work at different paces, depending on how the technology behind those subsystems was evolving. And what that ultimately gave you was a much broader reach for the automobile industry. It gave a lot more choice in different price points, different market segments that could be reached, and there's pretty much an auto for every type of consumer today. This all has been achieved through industrialization. Now, coming back to our industry, we've seen evolution along three dimensions. We've seen evolution along architecture, deployment and process. And when you think about this relative to cloud native, the further you move along to the right, the closer you are to cloud native. Many of you are on this path, or hopefully many of you are quite a long way on the right. Now, I'm sure many of you appreciate that getting there is not being an easy path. There's a lot of rocks in the path, and the complexity is really challenging at times. So the potential is great, but there's still a lot of work to be done to realize that potential and to make sure that we keep the complexity under control. Now, that complexity is driven by the nature of the software industry. Developers started off being, when we look back, it was relatively straightforward for a developer in the 70s, even going into the 90s. But as we started moving more and more towards cloud native, the demands and expectations of developers has become ever greater. It's not just the technologies, it's also the processes and the practices that they have to learn. This has meant cognitive overload for developers. And we're frankly reaching breaking point right now with what we're asking developers to be aware of, to learn and to be expert at. So I urge you to think about how to deal with this kind of crazy complexity. Here, you cannot even read all of the blocks. Now, for those of you that don't know, this is an overview of all of the technology building blocks in cloud native. It's a popular framework that's been shared by the cloud native computing foundation. And you can't even see what the building blocks are on this slide, let alone expect any individual to learn about what's here. So we need to simplify. First of all, really think about the use cases that you're trying to solve and take the right mix of technology to be able to solve those use cases. Don't take a technology-driven approach where you start with a fancy architecture and try to ram that into all of your use cases. Secondly, look at how you can automate the development process. You want to be able to reduce that cognitive overload on your developers. Give them the opportunity to focus on application logic and not on code around all of the non-functional aspects such as how to deploy their applications. And then, thirdly, take advantage of the latest organizational methods to prepare for better agility and to be able to scale up your organization. I won't cover it here, but a great path I recommend in this area, the concepts outlined in the well-known book Team Topologies and popularized in the industry as platform engineering. As I say, we won't go into that here, but moving forward right now, we're going to take these three steps to simplify and we'll map them to the popular process improvement triad of technology process and people. So we've got this triad here, and if you focus on improvement, you can't overweight your focus only on technology or only in process. You need a balance of improvement in each of these three areas. As you do that, you start to mature your capability and move forward. This way we saw in those earlier examples of the industry, the auto industry and the clothing industry, you begin to get closer and closer to that nirvana where you want to be of highly productive, delivering great applications to enable the competitiveness of the companies that you're working in. What I'll do now is to take us on a journey to explore some of the red hat patterns and how we tie that together to these three process improvement dimensions and help you on this journey. So before I get into showing some examples along those three dimensions, I'd like to start with an overview of what are red hat patterns? What is this about? Well, they're really looking at the types of scenarios and problems that you occur as you're on your journey to cloud native, and they provide repeated solutions to be able to move forward and unlock the roadblocks. They'll help you as you modernize your applications and as you adopt the cloud. Let's look at the three different pattern types we offer. On the left hand side, you have portfolio architecture. That's a high level looking at conceptual designs and architectures. It's very visual in the form of block diagrams. It's something that an architect or a CIO would be interested in. It gives them the opportunity to see proven implementations by other red hat customers. The two sets of pattern types on the right hand side are implementation patterns patterns. If you want the richest set of implementation patterns, go with a validated pattern if it covers your use case, and here you'll find patterns which are ready to be deployed into production. It's fully automated deployment, and red hat provides an SLA and tests these patterns over time as the underlying components go through version changes. The middle one solution patterns, think of that as a compromise where you've got some real code to help you with implementing the pattern. It comes with a sample app, so you see exactly how the architectural pattern is solved, but it's not something that you'd actually want to deploy directly into your environment in production. You take that as a building block and tie it together with other building blocks to create a specific architecture that suits the challenges that you're facing in your environment. Together, these three pattern types give you a full set of coverage for your journey to the cloud. Let's go back now to the process improvement building blocks and see how these relate and how they help you, and we'll just give some examples in each of the three dimensions. For the first dimension, well, we'll start off by actually giving some more insight to what a solution pattern looks like. What can you expect if you look for a red hat solution pattern? We'll take an example in the process dimension, and if you think about process, one very common challenge is that in a multi-cloud environment, it's really difficult to automate deployments of application code to different clouds at the same time. What we'll do is to take advantage of a solution pattern, which helps with multi-cloud deployments using Qtops. Let's jump into the demo, overview of the solution pattern. You'll see this with all solution patterns. It starts with an overview of the solution pattern itself. Then you can drill into the architecture. Probably, first of all, you wonder what are the actual components within this solution pattern, and you get an overview of which technologies, quite often these are red hat technologies, but they can also include technologies from red hat partners or from the open source community. Then there's an overview of the architecture itself, a graphical overview. Here we see thinking about our challenge on multi-cloud deployments. We've got a central management hub here, and this is showing that from the central management hub, we can unify and automate deployment to different managed clusters. Already we know we're very much on the right track. This is a pattern that will help solve the challenge we're faced with. It goes into more detail on exactly how some of the architecture works in practice, some information flows between the different architectural components, but then that's great. It's some documentation and paper, but let me see how this really works. We jump into seeing the solution in action, and you'll see with all solution patterns that there's a visual demo or video demo showing the solution pattern in action. In this case, we've actually got two demos that show this. That's really good to see in more detail, to ramp up your learning, but you'll probably want to even go further and say, well, that's good. I can see it, but I want to recreate this in my own environment. In that case, we provide full instructions on how to take this solution pattern and all the detailed instructions to actually run this, deploy it in your own environment. You now have an idea of what solution patterns are about. Let's return to have a look at a different scenario. For the second scenario, let's look at the technology dimension. This is all about what are the architectures that I want to deploy to help move towards Cloud Native. Let's have a scenario that I'm a technology executive and I'm looking for something. I'm working for a manufacturing company. I've got a central data center. I've got a variety of manufacturing plants dotted around the world, and I'm looking for some technologies to be able to better manage these edge devices on the factory floor. Let's see what Red Hat has to offer in this area, but I don't just want to hear from Red Hat what Red Hat has to offer. I want to explore and discover what other Red Hat customers have actually implemented. For that, I'll go into the portfolio architecture. Here we have a full catalog describing all of the different customer implementations using multiple combinations of the Red Hat portfolio. There's a lot here, so you can always browse it, but being a busy technology executive, I'll actually want to filter this. So I'll filter it going into Edge and have a look in Edge. What I see here is industrial Edge. That sounds pretty much what I could be looking for. Let's go in and see what industrial Edge is about. We see here it's got a factory floor element interacting with applications in the central data center. So I'm on the right track, more information of different components addressing different users, my DevOps team, the data analytics team, business analysts. So yes, this seems to be on the right track. I've seen an overview. I know customers have run this, but what are they actually running? Let's get into the implementation details. And for that, we go to a validated pattern. So for a validated pattern here, we'll jump straight into a demo, and I won't go through the full demo. This could be a bit of an eye test to see what's going on here. Very simply, it's a bit of MQTT-based instrumentation points, or feeding data around the environment using data streaming based on Apache Kafka. And then if you drill down to see an actual scenario that's covered in the demo, here we have a vibration instrumentation on one of the manufacturing devices, and the AIML behind this implementation detects vibrations and then recognizes anomaly spikes and vibrations, which then trigger a work order for an operator to visit the line and repair the device. So that's an example of just a simple instrumentation. But really, the heart of what this validated pattern is about is to show how you can automate the deployment of configuration from the central data center to those remote shop floor devices. Here we've got an example where we want to add a temperature sensor, and so that's simply done by making a change in the configuration file and then triggering the GitOps process to automatically deploy that. And the end result is that without any intervention on actually changing code on those factory data center systems, it's also been deployed automatically and you see the vibration sensors working as before. And now the temperature sensors have been added. As always, you can actually deploy this, and being a validated pattern, you can deploy this and run this directly in a production environment. So a really great set of capabilities. Let's go back now. So we're still on this discovery journey. And let's say now we'd like to see if we could leverage some of these concepts and apply them over in our retail arm of our business. And so our retail arm offers an e-commerce store, and they're trying to figure out how to put a recommendation engine together, and maybe there's something around Kafka and data streaming that could help. So to do that, we'll jump over to the solution pattern catalog. Here's a list of all the solution patterns that are available. Right at the top, we see a pattern that's available for, well, it's a recommendation engine using event streaming and Kafka's in there. Sounds very much like what I'm looking forward to. It's got the standard details you see here. So I wouldn't go through the full details. You've seen it's the same format as the first solution pattern example. What I would like to do now, though, is to show you an example of when you actually follow the steps to deploy this in your environment, what the end result is. So here we're going to actually go and see the result of going through this implementation, following the guided instructions, and you'll end up with an OpenShift cluster with an application deployed in your OpenShift cluster. What we have here, we've got a couple of ancillary services, and then there's the main application for the recommendation engine and the e-commerce website. The e-commerce website is a Node.js application, and that's feeding information, storing information in a Postgres backend database. There's some streaming going on that's taking care of handling the tracking of user activity on the website and then generating a list of recommended items to see in the site. Let's have a look at that site. So this is the starting point. Remember, all of this comes from the solution pattern and following the guided steps. So we've got a full web store here. This main page would normally show in this area here some featured products. This is the very first time that we're launching this, and so there isn't actually any user tracking yet. Let's go in and see the store itself. So these are browsing through the store, see lots of Red Hat memorabilia, also some IBM memorabilia in here. And okay, so this is the store. I'll now take you behind the scenes, and we want to track whether our Kafka streaming is working correctly. And to do that, we'll go into KafkaTrop, a utility for Kafka. And with KafkaTrop, we can see what's going on. It's tracking all of our Kafka topics. We'll go into the topic on global tracking. So that's actually just looking at the messages that are flowing through. At the moment, you'll see that there's no messages, a size of zero in the topic queue. So we're actually going to the website. We'll generate some user activity here, liking a few things. And with that, I'll go back into KafkaTrop. We'll refresh. And if everything worked out, the demo didn't blow up. No, it's worked. And we have four messages have been received in the Kafka topic for activity tracking. Now, how do we use it? What's the outcome of this? Well, if we go back to the shop store, and if we go to the home page, we'll now see based on the likes, and if you just imagine this scaled up for multiple users, we've got simulation engine that's also built in, based on user activity, and likes of different products, it comes up with a featured product list. And if you want to follow this offline later, you can play around with it yourself, invite your friends to also put their likes in and see how this all works in reality. So that took us through some discovery and exploration of patterns related to technology implementation. Now, I'd like to get us closer to the end and take us on a quick look at the third dimension of the triads around people. How do you improve organization? What can Red Hat do to help in this area? I did touch on something earlier around platform engineering. There is a lot that Red Hat does in this area. In this short presentation, I don't have time to go into that. You can expect at Red Hat Summit to see a lot of presentations talking about platform engineering. So I do encourage you to consider coming to Red Hat Summit. But what I'll share now are some very practical things that are accessible, right today. It's the open practice library. Now, this is based on the many years of experience of our consulting teams, our product teams working together with customers. And we've documented all of these different practices for improving teamwork between developer teams, between say developer teams and platform engineers or the implementing DevSecOps processes. All of this catalog of tools and processes is all available. And in typical Red Hat fashion, this is completely open source. So I do encourage you to explore that. Now, in closing, I'd like to leave three takeaways. First of all, begin to make the improvements on improving your developer processes and get ready by bringing your development practices into the up to the latest standard for cloud native and ready to scale. And you can do that by driving along maturity and taking a balanced approach across the triad of people, technology, process and people. And by all means, take advantage of the patterns that Red Hat shares with you so you can get a head start faster and you can simplify that complexity and find ways to reuse best practices of others that have gone on before you. With that, thank you so much. In the recording that you'll find on YouTube, you'll be able to take a picture of the QR code and have a look at explore those patterns for yourselves. Thank you so much. I don't know if we have any time for questions. I think we need to make a wrap. But if there is anything, Mr. Yeah, let's let's just wrap it up. There are what is the link to the open practice library, Mark? Maybe you can share that so I can. It's also a QR code. I'll put a link to that in the chat right now. Wonderful. Thank you so much. Thank you, Mark. And we'll be back in like two minutes. So hang tight while we set up everything else for the next two presenters.