Hands-On Domain Driven Design with .NET: Tackling complexity in the heart of software by putting the DDD principles to practice

BBM & Conway Law to end the story made me laugh because my current job involves maintaining such a system. Most of the day I spent writing horrible code. It occurred to me when I started learning .Net Core recently that technology changes suck as I have to update my skills every then & now. So I tried to give another try learning DDD after giving up on DDD couple of years back.So I started reading Eric Events Blue Book which is thick & has a lot of thought-provoking theory. I only read the first 7 seven chapters. Then started reading Jimmy book last week along with watched Plural Site videos as well but was burdened with "It depends on analogy a lot". Enough with history but this book is so refreshing that I actually want to write code & experiment it.I love the idea of using a rather simple domain like Ad application. I am no DDD practitioner because I have failed multiple times in the past just to keep EF Context out of my Domain Model rather I should call it Persistence Model.The key takes away from this book is:- Event Sourcing is not really difficult to implement as it sounds in start- Aggregate & Context Boundary was explained very well with a crisp exampleWhat this book lacks:- Event Sourcing downsides when there are changes to the model, perhaps an Entity is completely removed, or associations are changed in a way that it requires changes to existing data, like new property is added.- How to fix bugs since Aggregate is persisted to the event stream. Is it just like adding another event to stream so the state can be corrected like debit/credit?- How to fix Legacy systems, perhaps complete rewrite, but who will listen to an inexperienced DDD developer?Note: This is an initial review, I will be reading it slow & implementing what is being told, and see how I feel.

I haven't quite finished this book yet. I have read a few books and I'm always worried that they will go on and on about technical terminology and how it's going to save the world of software, but then you're left with an extremely vague representation of what something is. Anyway, as complex as people say DDD is, this book explains it very tersely. It makes sense and it's framed in a very coherent way with a great example. The fact that the book goes deeper into implementation than most will need, seeing it isn't confusing nor is it distracting. Everything is explained right there with modern code snippets. While I personally still see DDD as a pick-and-choose(depending on the complexity of your problem, your ORM, etc.), the book does a great job of explaining everything, and dissecting other methods like unit-of-work and showing their flaws. The author is aware and accepting of the fact that not every user needs every aspect of DDD. It's easy to continue on through the entire book if you aren't implementing something so similar, and the level of depth is quite deep for those who need it, and as a reference for those who may eventually. The book also couples testing and things like OpenAPI for a very modern approach.

The book covers a lot of advanced topics such as Domain Driven Design, CQRS, Event Sourcing and shows how these are actually applied in practice. Furthermore, the author does a good job explaining the rationale behind each concept. If you're looking to apply these practices in a .NET project, this is the book to get!

I've used the knowledge I've gained from my readings of this book to build my project, and it's helped me a lot not only understanding DDD but also object oriented design

This’s the best book on design patterns that I’ve spent on.

You will quickly surmise the quality of book when you start coding the "ClassidiedAdSentForReview" event. I prefer buying books from authors who will proofread their own work before publishing it. What makes it worse is if I download your code sample a year after your book was published and it still has the spelling mistakes in it.Also the author could benefit from collaborating with other experts when discussing content they are not familiar with. You'll see the need for it when the author discusses databases. Take those sections with a grain of salt. He discusses some important points but its hidden within some inaccurate statements and conjecture.I read it cover to cover, and implemented the code. A lot of the dependencies the book uses are now out of date and you'll find yourself doing a alot of rework if you pull the latest nuget packages. I wanted to make sure I was coding in .net core 3.1 (book is in 2.0) and I was suprised how much additional work I had to do to get the code to work. If you are planning to buy this book and .net 5 comes out, don't buy this. Go for a different book.

Easy to follow. Thought provoking. Had more than a couple of 'Aha!' moments

Clever engineering overall. I've adopted the DDD implementation used in this book for my own projects. Exposes you to useful technologies like document databases and a specialized event store. Event Sourcing is a very useful approach to DDD and a good introduction is given in this book. Source code is available online to complement the highlighted sections in the book, but may take a little effort to get running correctly.

Completed this within 1 month of time.I liked the way this books takes the practical approach to explain the each and every component of DDD.However, i could have been better if we include the following.How different context communicate with each other.How to handle the transaction.How DDD can help to identify the different micro services

había varias cosas que desconocía, en general me gustó

The book is mostly ok but it talks multiple times about chapter 13 where it will talk about advanced topics and a front end in vue and guess what? The book has 12 chapters.The GitHub repository has 13 chapters. Even on the last pages says “on the next chapter” and there isn’t one!!! It’s incredible. The worst part is missing those “advanced topics”Also sometimes the code examples are wrong or missing and the authors seems to jump from one place to another. It could be a great book if they would have proof read it before publishing.The concepts and writing are mostly ok, but it takes to much space and money to be incomplete.

One of the best technical books about DDD and Event Sourcing. Easy to read, easy to follow and made me think again about how I am developing software.