 Could you just give us a quick preview of what we can expect in your workshop microservices. Let's build some well Basically, I'm going to use what I call microservices, which are going to be very very very small pieces of code highly decoupled and Suitable for a sort of the fuzzy domains. So we're going to pick a fuzzy domain. This happens to be in this case Advertising on a web page And we're going to sort of build a system that you know in that you know six hours or so We're going to build a system that actually presents advertising in a very very flexible fashion There's me flexible in that if one of the services goes down as a matter we keep working on it We keep doing it And we're going to basically have a lot of running application within the first hour or so and then we're going to keep changing it and never take it down And that's sort of sets, you know, we're going to learn the lessons about microservices for fuzzy problems through that through the interaction So we'll hit some roadblocks We'll have some problems come up and that's where I sort of you know, these are by you pull out best practices I'm talking about some of the things I've run across that sort of handle some of these situations So basically it's basically how to use microservices for the fuzzy problems a lot of people use microservices or actually services To build good architectures and that's a perfectly good architecture But this is pretty for the fuzzy problems like fraud detection and the like or You know trying to figure this is a risky proposal or not. Should I loan you more money? Those sorts of things So the students usually walk away with much better understanding of that sort of problem and how you might solve it They're also impressed by how fast we write code And actually a lot of the agile practices that you think of as standard they go away in this environment Because we're actually deploying into an actually running environment and doing that means a lot of things you used to do normally go away So we'll wrap up the whole thing by talking about some of the challenges microservices creates especially if we're working to further the problems that are run across So again the target audience is people that are sort of going to work in those fuzzy domains Particularly using event buses because we'll be using an event bus on our own that process as well Okay, it's an event bus Yep, we're gonna we're usually I use things in progression in the production like Kafka and some of the newer ones In this case, we'll be using rabbinium Q because it comes up very easily. You can bring it up on your own laptop I will probably bring up some instances under a docker that we can share But that's the way we tend to decouple the architecture that each microservice basically Looks for things on the event bus that's interesting to it and draws conclusions and publishes those conclusions back on the event bus And therefore each one of them is very independent of the others There's looking at the little bit of data I'll pull some Jason off make some calculations and put some stuff back on the bus Yet you wind up with an interesting what we call choreographies Where there's not sort of some master services deciding what everyone else is doing That's a very tempting architecture for traditional architectures But in this case, it's a choreography where you know, basically one service is doing this the other But the other service which looks kind of silly Do you see the other service doing this and you put the two of them together and you have a dance And so basically we're gonna build some choreographies that way