Behaviour-Driven Development (BDD) is very much about conversations and examples but there is a software design part that can be used to bring BDD and Domain-Driven Design (DDD) practices together, combining the conversional bits with a domain-focused design activity, Konstantin Kudryashov explains in a presentation.
Move as much as possible of the behaviour away from the Entities into Value Objects when working with Aggregates, As more behaviour is needed this is added as new value objects, Paul Rayner recommends in a series of blog posts covering aggregates, entities and value objects, all concepts from Domain-Driven Design (DDD).
When using Domain-Driven Design (DDD) separating the concerns of a large system into bounded contexts with each context using its own data store there is often a need to share some common data. One way of doing that is to let each context publish events about changes, events that others can listen to, Julie Lerman recently explained in MSDN Magazine.
Layered systems are an architectural style used essentially to avoid coupling, the biggest enemy of software maintainability, with Ports and Adapters, or a Hexagonal Architecture, an example of such an architecture, Ian Cooper explains in a presentation about architecture styles, specifically the Hexagonal Architecture.
Domain-Driven Design (DDD) together with Onion Architecture is a combination that Wade Waldron believes has increased his code quality dramatically since he started using it a few years back. Using DDD was a kick-off but together with Onion architecture he found his code to be more readable and understandable, and far easier to maintain.
CQRS and Event Sourcing provide a clear and concise way to build distributed applications that adhere to the reactive manifesto, Duncan DeVore claimed in a recent presentation sharing his experiences building a distributed application using Akka and Scala.
Managing micro-services means looking after lots of small systems talking to each other and automated provisioning as well as infrastructure automation is crucial, James Lewis states when sharing techniques and practices that have helped him manage the increased operational complexity a microservice architecture gives.
Moving SoundCloud into a microservices architecture has been essential in enabling our teams to develop production-ready features with much shorter feedback cycles, Phil Calçado writes in a three-part series sharing their experiences moving away from a monolithic system.
DDD and CQRS are great for building scalable software considering concepts like bounded contexts, transaction boundaries and event based communication and is together with Akka a complete platform for building enterprise applications, Pawel Kaczor starts a three-part series building an reactive application based on these concepts.
By gathering all domain experts and developers in a room, provide them with a paper roll, lots of colored post-its and a facilitator they may in hours create the best model ever, Alberto Brandolini suggested at the recent DDD Exchange conference in London.
Delay of message sending into the future is a very powerful pattern and is often the preferable way of dealing with temporal problems compared to batch job that will run a query on the domain model and update some aggregates, Greg Young explained at the recent DDD Exchange conference in London.
High performance systems is about clean and representative models, the code doesn't have to be ugly, obscure and hard to read, Martin Thompson stated at the recent DDD Exchange conference in London.
We need to constantly challenge DDD to find the weak spots, Eric Evans stated in his keynote at DDD Exchange yesterday in London when walking through and challenging his own fundamental assumptions of Domain-Driven Design.
The sixth DDD Exchange Day in London is due in three weeks with a speaker list including Eric Evans, Martin Thompson, Alberto Brandolini and Greg Young. Eric will in his opening keynote challenge the fundamental assumptions of DDD and dig into the root assumptions to challenge each of them.
Implementing Domain-Driven Design (DDD) concepts using object orientation principles with state and behaviour often gives you a muddled mutable model, instead building domain objects with only state and behaviour as standalone functions leads to a better realization, Debasish Ghosh claims in a recent blog post.