Learn to use event storming as a scoping technique to identify microservices within your software model, as well as the contracts between them. You will also learn how to progress the event storming model into an organized set of .NET applications.
Event storming is a scoping technique used to identify potential microservices within your software model, as well as the initial event-driven contracts between them and also progress the architecture from the event storming model. In this course, Scoping and Organizing .NET Microservices Using Event Storming, you will gain the ability to scope and organize .NET microservices. First, you will learn event storming to scope and identify your microservices and their event-driven contracts. Next, you will discover incremental design practices to progress your event storming model into .NET applications. Finally, you will explore how to organize your .NET microservices. When you are finished with this course, you will have the skills and knowledge of event storming and incremental design needed to scope and identify .NET microservices.
Rag Dhiman is an experienced programmer who enjoys finding clean and expandable solutions to technological problems. He is MCPD and MCTS certified and a keen independent iOS developer with many Apps on the App Store.
Course Overview Hi everyone, my name is Rag Dhiman, and welcome to my course titled, Scoping and Organizing .NET Microservices Using Event Storming. I've been developing and architecting software at a commercial level for well over 15 years, and along this time I have witnessed at first hand what works and what doesn't work when it comes to designing and modeling software, and I can tell you a technique called event storming, when combined with incremental design, provides a highly effective team-based collaborative and an iterative approach to modeling your microservices architecture. Also, when successfully done in succession, event storming and incremental design not only scope and identify your microservices, but also naturally develop an event-driven asynchronous architecture that easily translates into queues and messages, almost giving you an event-driven asynchronous microservices architecture for free. The good news is this course teaches you event storming and incremental design using a hands-on methodical and practical way, all done using a digital whiteboard, along with a very real lifelike case study. And finally, at the end, the course will conclude with a strategy on how to organize your .NET microservices in terms of source control repositories, .NET solutions, and projects. By the end of this course, you'll be fully skilled up in terms of scoping and organizing your .NET microservices. Before beginning the course, you should be familiar with agile-styled team-based software development. So I hope you'll join me on this journey to learn the most effective way of designing and modeling your software architecture with this course at Pluralsight.
Introduction Hi, this is Rag Dhiman from Pluralsight, and welcome to this introduction module of my course titled, Scoping and Organizing .NET Microservices using Event Storming. And we're going to start off this module by presenting the exact thing that the strategies and the techniques in this course are going to help you avoid, and most of us will be familiar with this example. It's our old friend, the monolith-based architecture. And hopefully by demoing this beast and all its flaws, we will get you excited about the strategies and techniques in this course, which will help you scope and organize your .NET microservices. And then we'll move on to looking at some of the reasons behind why we end up with this type of architecture and the obvious need for scoping techniques to avoid this situation. And in order to give you a quick insight into how effective .NET microservices look that have been developed using a scoping technique, we will give you quick insight into the scoping sessions and the incremental design process that led to the set of .NET solutions and projects. The good news for you guys is we'll be using a very real lifelike case study to build an architecture for using these scoping sessions and using the incremental design processes described within this course. And everything will be demoed in a very hands-on practical way and accompanied by a cheat sheet so that you can actually do this in real life. So at the end of this module, we'll focus on that case study so that you understand it in detail and you're ready for the rest of the course in terms of doing the scoping sessions to solve the problems within the case study.
Scoping Techniques in Practice Hi, this is Rag Dhiman from Pluralsight, and welcome to this module titled, Scoping Techniques in Practice. And in this module, we're going to look at a few scoping techniques that help scope our microservices and help overall scope our microservice's architecture. And the key technique that we'll focus on is something called event storming, and we'll start this module by looking at exactly what's required for an event storming session. And then we will progress the module by demonstrating each one of the steps that you will need to carry out in order to do an event storming session. So not only are we going to demonstrate each one of these steps using the case study that we introduced in the previous module, but for each step, we're going to provide a cheat sheet so that you can carry out each one of these steps in real life as part of your own event storming session. And then we're going to conclude the module by looking at additional techniques that you can use in addition to event storming to further consolidate and decompose your microservices.
Organising Microservices and Shared Components into .NET Applications Hi, this is Rag Dhiman from Pluralsight, and welcome to this module titled, Organizing Microservices and Shared Components into .NET Applications. And in this module, we'll start off by looking at incremental design as a technique to progressively develop our software architecture using the output from our event storming sessions as a starting point, and you'll see how the combination of event storming and incremental design can be used to identify our initial set of .NET microservices in the form of APIs and services and the event-driven contracts between them. We will them move on to looking at how we can organize these .NET microservices in terms of source control, in terms of .NET solutions and projects, and in terms of continuous integration and continuous delivery projects. And then we will conclude the module by presenting a strategy on how to share code between your .NET microservices.