Clean Architecture: Patterns, Practices, and Principles

Course Overview
Hi. I'm Matthew Renze with Pluralsight, and welcome to Clean Architecture: Patterns, Practices, and Principles. Clean architecture is a set of practices used to create modern software architecture that is simple, understandable, flexible, testable, and maintainable. In addition, clean architecture is a more modern replacement for the traditional three layered database-centric architecture that we've been using for decades. As an overview of this course, first you'll learn about clean architecture, what it is, and why it's important. Then, you'll learn about a series of modern architectural practices, like domain-centric architecture, application layers, command query responsibility separation, functional organization, and microservice architectures. Finally, you'll see how these architectural practices make your architecture more testable, more maintainable, and allows the architecture to evolve over time. By the end of this course you'll have the skills necessary to understand and implement these clean architecture practices on your own software projects. In addition, throughout this course we'll be walking through an open source application that implements all of these practices, so you can see how they're implemented first hand. As an introductory course, there are no prerequisites for this course. However, having basic experience with at least one C like programming language, and basic knowledge of software architecture will be beneficial, so please join us today at Pluralsight, and learn how to create highly effective and maintainable software with clean architecture.

Domain-centric Architecture
Hello again, and welcome to our next module on clean architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about Domain-centric Architecture. As an overview of this module, first we'll learn about domain-centric architecture and how it differs from database-centric architecture. Next, we'll learn about three types of domain-centric architectures. Then, we'll learn about the pros and cons of implementing a domain-centric architecture. Finally, we'll see a demo of our domain-centric demo application, so let's get started.

Application Layer
Welcome back to our course on clean architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about using an application layer in our architecture. As an overview of this module, first we'll learn about architectures with an application layer, and how this differs from a traditional three layer architecture. Next, we'll learn about the dependency inversion principle, and how we can use it to make our architecture more flexible and maintainable. Then, we'll evaluate the pros and cons of implementing an application layer. Finally, we'll see a demo where we'll walk through the code used to implement a command in the application layer of our demo application.

Commands and Queries
Welcome to our next module on Clean Architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about using commands and queries in our architecture. As an overview of this module, first, we'll learn about commands and queries, and how we should strive to keep them separated in our architecture. Next, we'll learn about three types of CQRS architectures. Then, we'll discuss the pros and cons of CQRS practices. Finally, we'll take a look at the query side of our demo application, so let's get started.

Functional Organization
Hello again, and welcome back to Clean Architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about Functional Organization in our architecture. As an overview of this module, first we'll learn about the screaming architecture practice. Next, we'll learn about functional versus categorical cohesion. Then we'll learn the pros and cons of using functional organization. Finally, we'll see a demo showing the benefits of this style of organization.

Microservices
Hello again, and welcome to our next module on Clean Architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about Microservices. As an overview of this module, first we'll learn about bounded context and how they can be used to subdivide a large domain model. Next, we'll learn about microservices, and how they can be used to subdivide a monolithic architecture. Then, we'll learn about the pros and cons of using microservices. Finally, we'll see how our demo application communicates with an inventory microservice.

Testable Architecture
Hello again, and welcome to our next module on Clean Architecture. I'm Matthew Renze with Pluralsight, and in this module we'll learn about Testable Architecture. As an overview of this module, first we'll learn about Test-Driven Development, and how it drives the design of an architecture that's testable, reliable, and maintainable. Next, we'll learn about the test automation pyramid, and the various types of tests that we can create for our architecture. Then, we'll discuss the pros and cons of implementing a testable architecture. Finally, we'll see a demo of our testable architecture in action, so let's get started.

Evolving the Architecture
Hello again, and welcome to our final module on Clean Architecture. I'm Matthew Renze with Pluralsight, and in this final module we'll learn how to evolve our architecture over the life of the project. As an overview of this module, first we'll discuss how we can evolve our architecture to reduce risk due to uncertainty and changing requirements. Next, we'll discuss where to go for more information if you'd like to learn more about the topics in this course. Finally, we'll wrap up this module and the course as a whole.