Domain-Driven Design in Practice Pluralsight course

By Vladimir Khorikov

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
  • Repositories
  • 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.


  • Aleksandras

    Nice to hear about such course – I was always struggling to find end-to-end DDD example, which is not outdated and which uses modern technologies. I would definitely look at it (I have pluralsight subscription).

    Although it would be good if you mention more specifically not just principles, but also technologies you are using in your course. For example you mentioned so many times about ORM, but didn’t mention about which exactly. Or is it .NET/ASP.NET, or maybe Java?:)

    I understand you probably wanted to abstract from specific technologies, but you are speaking about real-life example.. and such details are important considering a real-life based course.:)

    • Vladimir Khorikov

      Good point. In terms of technologies, the course uses SQL Server, C# 6.0, NHibernate, and WPF in conjunction with the MVVM pattern (hope I didn’t forget anything). In terms of tools, it’s Visual Studio 2015, xunit, SQL Management Studio, Resharper and NCrunch.

      You are right that I try to position it as technology-agnostic and you are right that it’s impossible given the “in practice” inclination of the course :) I’ll add this info to the announcement, thanks for the remark.

      Also, a quick note: although the project uses WPF, I apply the same principles when I work on web backend projects.

      • Alexander Yevseyev

        What library do you use for MVVM pattern (like Caliburn.Micro, MVVM-Light) or none at all?

        • Vladimir Khorikov

          None at all. The sample project in the course isn’t terribly complex, so I decided not to introduce additional libraries there.

  • Denis Oliva

    Hi Vladimir this is a great course. I tried to apply the event tactical implementation in a project on git hub but the reflection is not working on the unit test for the Handlers. Not sure if is a minor thing that I ma missing but is almost the same implementation that showed in the course. If you have an opportunity could you take a look at it maybe you find the issue in 5s. “”

    • Denis Oliva

      Thank you Vladimir for taking time on checking this and let me know on twiter. I found the issue. It was reflection and the kind of organization of the project classes. To triggerthe whole process on the unit test project I need to get the handlres using GetCallingAsembly instead of executing

      • Vladimir Khorikov

        Thanks for letting me know. Reflection can indeed be quite frustrating to debug.

        • Denis Oliva

          Yes indeed. I created a nugget package based on your idea of event implementation register-dispatch. It is here and in its is github link. So developers can add events to domains. I think this could be useful not only for DDD architecture but also for architectures with less tactical DDD patterns but that want to use events to handler and decoupling change of object state. Feel free to contribute to the project if you have time. Thank you