My DDD in Practice course for Pluralsight went live.
Why should you watch this course?
I’ve been consistently applying DDD principles in my projects for about 6 years now and I can’t express enough how much value Domain-Driven Design has brought to me. The blue book written by Eric Evans was the most influential book I’ve ever read in my career.
If you read this book too, you must have noticed that while it provides invaluable insights, it doesn’t tell much about how to implement them in practice. It becomes especially frustrating if you consider the progress made by the modern ORMs and programming languages. It’s clear that if you rely on a relational database in a fairly complex software project, you can’t avoid using an ORM. At the same time, it might be uncertain how to keep up with the DDD principles: how not to fall down to data-driven development with an anemic domain model and still get the benefits the big ORMs provide.
In this course, I cover such topics. You, as a viewer, will go through the full development process of a quite complex application and will see how to apply Domain-Driven Design in conjunction with other best practices: unit testing, KISS and YAGNI principles, MVVM design pattern and more. You will see how to keep the domain model clean and isolated in the face of tight constraints relational databases impose and how to prevent ORM from infiltrating into your domain classes.
Throughout the course, I show how to grow a fully-fledged application from the ground up. DDD concepts are introduced gradually, without putting a lot of pressure on the viewer.
If you read this blog in a regular manner, you might have noticed that I extol the YAGNI and KISS principles. The sample project in the course is implemented with these principles in mind. It’s interesting that DDD itself fosters application of these principles by focusing on the essential parts of the software (the core domain) and simplifying it using the tactical patterns (entities, value objects, and so on).
The course covers such topics as:
- Onion architecture and domain model isolation
- DDD and unit testing
- Entities and value objects and the differences between them
- The work with a relational database using an ORM
- Aggregate design best practices
- Bounded contexts and subdomains
- Domain events and two ways of handling them in code
- DDD anti-patterns
And it is not just some theoretical explanation. All these topics are illustrated by functioning code written in the context of the software project we work on throughout the course. The knowledge gathered in this course is the essential part of what I learned about DDD during many years applying it in real-world projects. The code itself (for example, the base entity class and the code for dispatching domain events) has stood the test of time in many production systems, so you can safely use it in your own projects.
In terms of technologies, the course uses SQL Server, C# 6, NHibernate, and WPF (in conjunction with the MVVM pattern). In terms of tools, it’s Visual Studio 2015, xunit, SQL Management Studio, Resharper and NCrunch. Although the course shows a desktop application, the same principles are applicable to programming backend for server projects.
You can watch the course here: link
Also, if you want to watch it but don’t have a subscription, write me an email and I’ll send you a trial code with which you’ll have an unlimited access to the Pluralsight library during 30 days.