11 ms·
Domain-Driven Design
- baybal2 5y agoWho is Mathias Verraes?
- robjan 5y agoHe has an "About" page and links to his LinkedIn profile on his website.
- ToJans 5y ago* Disclaimer: Mathias is a personal friend of mine, and I was heavily involved in the European DDD community over a decade ago. * Mathias is one of the original instigators of the European DDD community: he spent the last decade giving talks all over Europe about DDD and organizing one of the largest DDD conferences in the world: DDD Europe [0]. Next to this he also has a consulting org (recently rebranded to Aardling [1]), and spends a lot of time with DDD gurus like Eric Evans (the "inventor" of DDD, author of the DDD blue book), Alberto Brandolini ("inventor" of event storming), Nick Tune, Paul Rayner, Yves Reynhout, Cyrille Martraire, Romeu Moura, Marco Heimeshoff, ... As far as I'm concerned, he's the real deal, and has skin in the game. Highly recommended! [0] https://dddeurope.com/ https://dddeurope.com/ [1] https://aardling.eu/ https://aardling.eu/
- BossingAround 5y agoIf someone wonders about DDD, I'd recommend Lightbend's free courses, e.g. [1]. They don't go too in-depth and you can take all of them (I think five?) within a weekend. [1] https://academy.lightbend.com/courses/course-v1:lightbend+LRA-DomainDrivenDesign+v1/about https://academy.lightbend.com/courses/course-v1:lightbend+LR...
- deleted 5y ago[deleted]
- Fiahil 5y agoI attended a few DDD meetup a few years ago, and it never quite made sense why would you engage in this kind of architecture nowadays. The room was filled with experienced Java developers with deep Enterprise Software(tm) knowledge. Then, I started working as an AI Software Engineer (mix of a software engineer + devops + data scientist), and it all clicked. DDD is a wonderful design pattern for anything related to Data Science, AI, ML. Why ? because 90% of your problems is retroactively making sense, organizing, sorting, filtering, aggregating all the data you got from your favorite Data Base/Lake/Wharehouse. DDD let you have a unified language, invariant definition and expectations between your existing business challenges and the analytics your are running on it. It's very good for validating assumptions accross a dataset, for example: Sales amount can never been < 0 ? Let's check that... Oh well, you forgot about returns, so now you can define them and be explicit when to include or exclude them.
- adam_ellsworth 5y ago> invariant definition What's that? I haven't encountered that terminology before.
- Fiahil 5y ago"Sales quantity are always > 0"; "Ticket number are unique"; "Returns are always linked to an existing ticket" You know, stuff you usually put in assert statements. Except in real life you don't have strict application of these laws in the data. So you need a way to find out what percentage of your data is "misshapen" and what to do with them. You can't necessarily filter them out, because they might reflect some business process with relevant information. You goal is to easily identify these outliers without crashing your processing (that would be stupid).
- buzzwordninja 5y agoInvariant: doesn't vary. Things that always are (or should be) true.
- MihaiSandor 5y agoAnd the most important thing is that you have clear benefits in communication using a common domain language.
- seanwilson 5y ago> Software for a complex domain requires all designers (engineers, testers, analysts, …) to have a deep, shared understanding of the domain, guided by domain experts ... That understanding is rooted in language: the domain language should be formalised into a Ubiquitous Language (shared, agreed upon, unambiguous) ... > DDD is not prescriptive. It doesn’t have rules of how to do it, and is open to new interpretation. It doesn’t prescribe methods, or practices, and even the patterns in the book1 are meant to be illustrative rather than a final set. ... > That makes DDD notoriously hard to define. I don't know anything about DDD, but if you can't concretely describe it and how it's different to how teams naturally work together, how can it be actionable and what stops it becoming another cargo cult when nobody can agree on what it is?
- athrun 5y agoI recently came across this talk from Scott Wlaschin titled "Domain Modeling Made Functional". I found it a great practical introduction to DDD. https://www.youtube.com/watch?v=PLFl95c-IiU https://www.youtube.com/watch?v=PLFl95c-IiU
- dagw 5y agoIf that talk speaks to you (as it where) I can also highly recommend his book with the same title, https://pragprog.com/titles/swdddf/domain-modeling-made-functional/ https://pragprog.com/titles/swdddf/domain-modeling-made-func... They are the probably the best concrete and actionable introductions to DDD out there, and do a very good job of separating practical DDD from the OOP dogma that it is sometimes tied to. The book uses F# as it's language to implement and demonstrate its examples, but most of the concepts are presented in a language agnostic way.
- keithnz 5y agoI find it hard to understand how you'd get the essence of the idea from some of these descriptions, I was lucky enough to be at OOPSLA when Erics book came out and he had a session on it, I think he explained it pretty well, not sure if there are online presentations of his that are good, his book is good, but has a lot of extra more "technical" stuff to deal with how to implement it.
- tinco 5y agoSo this is a very fundamental explanation of DDD, the kind you might learn at university. But the last time I researched DDD there was a very concrete architecture associated with it, and I didn't really understand why. Every DDD article would also introduce CQRS for some reason, it seems they are inextricably connected, at least for web application development. Anyone got a good story on that?
- dm3 5y agoUnfortunately there isn't a single definition of DDD accepted by everyone. At its core DDD is about the practice of software design which puts Domain - user language and problems - first. There are no technical considerations. ES (Event Sourcing) and CQRS are technical patterns people like to use while doing DDD because of various reasons, but they're in no way required to practice DDD.
- mhd 5y agoI've seen architecture presentation where it seemed like event sourcing took DDD hostage, just using it as a vehicle to sell that particular astronaut-ism. Not even a ubiquitous language...
- berkes 5y agoI think part of the reason is that event-sourced needs DDD. So any story or presentation about ES, will at least mention DDD. But DDD, by no means, needs ES. Another part of the reason, I think, is because many other architectural patterns have taken certain concepts 'hostage'. Take for example Rails. MVC. 'Model' in Rails has a clear and distinct meaning, place and implementation. There is no way to have a bounded context, isolated domain models in Rails, without at least the terminology becoming very confusing. Having root aggregates in Rails makes all that worse, even. What I'm trying to paint, here, is that ES naturally embraces DDD, whereas other architectures often conflict, or require effort to fit in DDD. Therefore, you'll probably find many talks about ES or CQRS and DDD, but hardly any about Actor, MVC, etc., and DDD.
- jrochkind1 5y ago
- oscarcp 5y agoWe use DDD at the current company I work in and to be honest, I detest it so much that sometimes it makes me wonder if I even want to continue in the programming space (been at it for 20 years). Don't get me wrong, DDD has meaning and purpose, but some companies are applying it as a badge to be obtained instead of pondering the question, do you really need to rewrite everything following DDD? In our case, simple CRUD APIs that in "regular programming" might take a couple 200 line files have turned into unmanageable nightmares in DDD that take you at least a couple of days of really intensive investigation to understand, because it have been divided in more that 25 files that hold 3 or 4 lines of code at most, with so many abstraction layers that it's impossible for the best of us to follow in one go. Now, you could make the argument "You Are Doing It Wrong(tm)" but since I'm just a drone in this specific scheme and there's no wiggle room for anything (the team is quite inflexible on this) I have to follow it to the letter. Just giving my two cents, again, not depreciating DDD, it has its purpose but in my opinion, it's for very specific projects.
- macando 5y ago> it have been divided in more that 25 files that hold 3 or 4 lines of code at most, with so many abstraction layers that it's impossible for the best of us to follow in one go. When you put engineers in charge you get overengineering and when you put managers you get underengineering. Is there a way out?
- oscarcp 5y agoAt the moment, there's no way out, plannign stipulates that all our microservices must be rewritten to accomodate this super abstract DDD design (and youy're right, it was an engineer who created our current layout)
- deleted 5y ago[deleted]
- tragomaskhalos 5y agoThis is so true, and has been forever. In the early 90s I worked on a system where you couldn't just write structs, rather you had to submit their definition to a guy who entered the details into a database, and there was a daily run to generate the C header files from that database. To this day I'm convinced the only reason it was done this way was that it could be done this way.
- pmontra 5y agoI didn't read the PDF but it seems a way to formalize the usual analysis of customer requirements. It goes like this: 1. Understand the business of the customer, or any requirement won't make sense. 2. Learn the jargon of the business, or you won't be able to communicate. 3. Use that jargon when naming database tables, software modules, variables, everything, or you'll have to translate between your possibly abstract names and the jargon of the business. So, apparently nothing new but I should read the PDF (too bad it's not HTML) because there could be new useful ideas about the process. Edit: oops, the PDF is only that page as PDF. I'll google for it but does anybody have a good link to a detailed explanation of the method?
- amw-zero 5y agoThe post is just this web page. You just need to read the posted link.
- torginus 5y agoI clicked this article to find out what DDD is as I've heard the term and was curious to learn more about it. Unfortunately, this article does very little to enlighten me besides the very basic common sense stuff, like understanding the business domain/keeping in close contact with the people who do. The above idea is hardly revolutionary anyway, I'm sure many people operated this way DDD or not. This seems like another one in the endless stream of innovative project management methodologies that promise to make everything better, but whose main purpose is creating lucrative make-work opportunities to the next batch of consultants and evangelists.
- dagw 5y agovery basic common sense stuff, like understanding the business domain/keeping in close contact with the people who do. Much of DDD is common sense, what it offers is a way to be explicitly common sense. The important factors, the way I see it, is to explicitly make sure both developers and stakeholder have a shared mental model of the business process that maps to the domain in question, they all agree on which 'jargon' terms map to which parts of that model AND that that model (with the agreed upon terms) is explicitly represented in the code. Keeping in close contact with the business domain people is most useful if you actually understand each other. Too often I've seen developers and business people using the same 'every day' word when discussing a problem and only much later do they find out that their obvious understanding of that word was very different.
- abacadaba 5y agoNope, still means nothing too me. I'll just accept that how this bucket of words is supposed to form some cohesive methodology or pattern for anything is beyond my understanding. I'm sure some people get paid a lot of $ to implement it tho.
- dagw 5y agoSimple Version. Before writing a function that reports how many of a certain thing has been "sold", make sure everybody involved agrees what "sold" means in this specific context and domain. And once you have agreed, make sure that every time a function, variable or database table talks about things "sold" it's using that definition. How complex your methodology around this has to be depends entirely on how complex the domain is and how many different definitions of "sold" is used with different parts of that domain.
- reverseblade2 5y agoMark my words, DDD without cqrs is a futile attempt.
- tester34 5y agoDDD is a software engineering concept that if you took 100 software engineers with decade of experience, then 30 of them would have no idea or understood it bad, and then you'd have 70 different interpretations funny anecdote: at my last semester of eng. degree there was presentation to perform about some fancy topic. One person who had I guess like 2 or 3 years of xp decided to pick DDD and thought he'll manage to do it like a day or a few before presentation He failed kinda hard with understanding it
- latte 5y agoThe principles listed in the article look like general common-sense design principles. I can hardly imagine anyone designing a system without understanding the problem domain first - and likewise, the problem domain usually drives the underlying models (because what else can they be driven by)? I acknowledge that something the design process strays away from the original domain requirements (especially among the less experienced teams), but that usually feels wrong irrespective of the design philosophy. So the definition of DDD seems a bit tautological. I would appreciate an explanation of what DDD is by counterexample - i.e. what are examples of non-domain driven design process? Especially, examples of successful or mostly successful projects - i.e. where the disconnect from the problem domain does not feel wrong from the start.
- HelloNurse 5y agoTypical oldschool enterprise software that has database tables instead of a decently abstract model, pages instead of services, "it should happen very rarely" instead of invariants, "don't do that" instead of validation, lore instead of design, etc. What's particularly contrary to DDD principles and common is mixing up different concerns without regard for model integrity (e.g. ad hoc incorrect caching of stale data for performance reasons, messing up all business logic).
- scoopr 5y agoNow for a second there I was a bit confused and thought this was about forming your business ideas around the available .com domain names. My guess was wrong, but I'm still confused what it is about :)
- _pmf_ 5y ago"Making illegal states unrepresentable" is one of the worst possible pieces of advice I ever encountered. It sounds very reasonable, but as soon as you face the issue of communicating to the user or other components the fact that something is wrong and what is wrong, you'll discover that it is very hard to inform about illegal states if you cannot represent them.
- nivertech 5y agoThe reason to make them unrepresentable so you will be able to catch the case when the input was illegal. Otherwise you may never notice that illegal state was there in the first place. I encountered many systems that would take invalid inputs and produce invalid (but sometimes even valid) results [1]. Illegal internal states are even harder to catch. When using FSM / StateCharts I usually automatically print error to log (and crash) for all illegal state/event combinations in the State Transition Table, instead of silently ignoring them. [1] GIGO - Garbage In Garbage Out https://en.wikipedia.org/wiki/Garbage_in,_garbage_out https://en.wikipedia.org/wiki/Garbage_in,_garbage_out
- cloogshicer 5y agoThat's not what "Making illegal states unrepresentable" means. Let's say you're trying to parse a user object. Let's further say users always have to have a last name - a user without last name would be illegal state. Now if you're parsing some data for a user that really doesn't have a last name for some reason, there's two approaches to this problem - either you return a User with a null last name (which is essentially giving incorrect information to the caller). Or you make it impossible to set User.lastName to null (for example by making it an Optional) and fail with an error about what went wrong. Of course you wouldn't NEED to restrict User.lastName to never be null - but if you always fail with an error in that case anyways, why not? That way any consumer of the User object knows that the lastName will always be there and valid.
- HelloNurse 5y agoBut clearly, requiring a last name is wrong. If legitimate users can lack a last name, the system needs to work without last names: probably there should be a flexible "person's name" class that encapsulates first names, last names, titles etc. instead of attaching a raw last name to users.
- revskill 5y agoI think domain driven design is born to differentiate with database driven design. So we design at a higher level, our thought process, vocabulary is tied with business terms.
- xtracto 5y agoWe used to design systems at a higher level with UML: Use Case diagrams were meant as a design tool to talk with the product owner about the subjects and verbs of the domain. Sequence diagrams allowed us to capture any dynamics and interactions at the domain level. That was like 25 years ago.
- mathiasverraes 5y agoThe definition is highly summarised, which (like many definitions) makes it only useful if you already understand the concept, and you need a way to remember it. Or the definition can be a framework for explaining it to others, which is how I use it in workshops. A more real world story of DDD in practice is this blog post: https://verraes.net/2021/09/design-and-reality/ https://verraes.net/2021/09/design-and-reality/
- kklisura 5y agoRemember when people got offended by the "DDD" acronym? [1] "Good" times... [1] https://twitter.com/sarahmei/status/1073251153360482304 https://twitter.com/sarahmei/status/1073251153360482304
- jdthedisciple 5y agoLOL If only people understood the same letters can be used for multiple acronyms https://en.m.wikipedia.org/wiki/DDD https://en.m.wikipedia.org/wiki/DDD What's even funnier is that none of the acronyms listed there is a soft-porn reference as claimed in the twitter thread.
- JohnWhigham 5y agoI just don't understand people that insist on bringing their emotional baggage into absolutely everything.
- nocture 5y agoDDD strikes me the software version of Agile sometimes. The ideas and philosophy behind are good, but ends up being taken as a silver bullet. If you do this you will have a good architecture and your software will be well architected. Especially in the .NET world i've seen DDD being branded together with CQRS as "Clean Architecture" which in reality turns out to be a mess of layers and separations.
- arkh 5y ago> DDD strikes me the software version of Agile sometimes. DDD is more about managing your business software needs than making software. If you read "Implementing DDD" a good thing to take from it the fact you should focus your efforts on your business core value add. It's where you put your best developers, architects and money. Anything outside this core will get less resources and can often be outsourced. And to evaluate what is this core and what is needed, you need your technical team to speak often with the domain experts. Using some common language. The coding aspect is itself agile as usually there will be miscommunication at first between your tech team and your expert giving you a less than good result. More communication, more knowledge shared and understood will make you think differently about your product and its architecture: that's when you refactor.
- jgrodziski 5y agoI made this introduction to DDD [0] with my friend Thomas a few years ago. It was specifically intended at developers and to be very practical. [0] Video of the talk: https://vimeo.com/167722768 https://vimeo.com/167722768
- jgilias 5y agoDDD seems to be one of those things where 'what it's meant to mean' is very different from 'how it's actually practiced'. Reading about what it's meant to mean, it seems pretty common sense. As often implemented, however, it seems to lead to a lot of accidental complexity and a bunch of dubious usefulness abstraction layers. I have a theory why this is. It seems that enterprise development as a field have a penchant for methodologies and acronyms. So, whatever silver bullet the enterprise-y shops get interested in eventually gets enterprisified. Be it UML, OOP, Agile, or DDD. EDIT: I've found this an interesting read that sheds some more light on DDD using counter-examples: http://media.pragprog.com/titles/swdddf/understand.pdf http://media.pragprog.com/titles/swdddf/understand.pdf
- softveda 5y agoIn my 22 years of career in Software starting as a developer I have seen DDD used only one time successfully and appropriately. All other attempts were half baked and over engineered mess. The one time it worked is a very complex domain of insurance policy administration. It had highly complex business rules and had to maintain invariants. The original developers were all experienced and senior from a consulting company. I joined as a permanent member of the team before handover. The problem was that over several years it was a hard time to get new hires up to speed to maintain the complex code and test it. Moreover even the ubiquitous language starts to change with new CEO, SMEs retiring, change in market etc. E.g. Member became Customer. Now you either refactor the entire codebase or have the code different to the new business jargon. Guess which one was chosen? Over time it became hard to refactor. I have now left the company many years back, but I am assuming this code still lives. Then I worked in enterprises where this kind of core systems were built in some humongous monolith like SAP, maintained my an army of people from WITCH companies. All the digital apps, web portal etc. was a frontend, API and caching layer. The DDD complexity was in the bowels of SAP or PEGA or Dynamics etc.
- necovek 5y agoLike the original post fails to mention any stakeholders when it comes to developing "Ubiquitous Language" (it enumerates "engineers, testers, analysts, …", and I don't think ellipses does any justice to them), most people forget that DDD is about modelling the real world before you start coding. My experience is that, unfortunately, majority of developers are either not experienced enough, or smart enough (these are closely related), to keep the abstraction creep at bay and apply only meaningful abstractions. And others are simply not interested enough, and they know they can get a LGTM with following misjudged patterns. They also jump at the opportunity to use identical terms from the DDD book, and then keep explaining them with more colloquial terms everybody understands: it's like social sciences all over again (sorry social sciences, but it's what it is) where they invent terms so they'd be more "scientific". Why not simply use the terms everybody understands? I get the argument that a new language allows for consistency, but it still gets misapplied, because it's the same humans doing the work. I can't think of a better parallel than SQL-vs-noSQL databases: sure, no-ACID makes a bunch of things simpler, but then every developer has to think through all of the same problems ACID DBs solve, and majority will get them wrong (or maybe even everybody would get them wrong _most of the time_).
- arkh 5y ago> majority of developers Jump to coding or architecting because that's their happy place. That's easy, that's what they know so they think that's what they've been hired for. Shelling some dollars to buy an off-the-shelf solution for some ancillary application? No thanks we think we can do it ourselves and have more control over it. Let's go coding.
- Kototama 5y ago> 's like social sciences all over again (sorry social sciences, but it's what it is) where they invent terms so they'd be more "scientific". Why not simply use the terms everybody understands? To be precise probably. Every domain develops a jargon at some point. It can be used to exclude or sound smart but most of the time it just to be precise. Common terms are too much vague / polysemic. Why do you need words like compiler, linker, dynamic and static types and linter instead of using common words?
- gibsonf1 5y agoThis principle is a key flaw in the idea: "A complex domain can not be efficiently expressed as a single universal model and language, and must therefore be separated into Bounded Contexts (ie. an internally consistent language and model) by the system designers". We humans understand how everything we experience is part of a wider world. So if you are unable to know how things relate, as all things do, you do not yet understand the domain.
- digbybk 5y agoI don’t think it’s accurate to say that DDD advocates ignoring how things relate. It’s more like finding the higher level concepts that do relate to each other. You don’t need to know about internal combustion to write traffic rules. In fact, it’s better if you don’t know about that because your rules shouldn’t need to change when the mechanism that moves the car changes.
- gibsonf1 5y agoSeparating things into bounded contexts sounds like specifically not connecting them, which means not understanding how they connect or even trying. And its these bounded things that seem to cause the biggest issues later on when their actual connections come to the surface as bugs in the system.
- kwhitefoot 5y agoI feel that I must be missing something. How else can one design anything?
- jasonhansel 5y agoDDD is a wonderful idea and one that I think should be applied more broadly: a deep understanding of the problem domain, shared between tech and product, can greatly improve quality, reduce bugs, simplify communication, and even result in better structured code. In particular, it tends to lead to code structure that follows the structure of the underlying problem domain, which tends to be much clearer than code that just tries to implement features without an underlying understanding of their purpose. The design patterns and actual implementations traditionally associated with DDD, on the other hand, are quite bad, and tend to lead to Enterprise Software levels of cruft and/or excessively dogmatic use of OOP.
- sovietmudkipz 5y agoI am working really hard on how to apply DDD to a video game context, specifically with unity3d. It is a struggle because I think the game creator cultural zeitgeist doesn’t like applying software patterns from ‘outside’ influences, like enterprise software. It is my personal view that the zeitgeist is terribly short sighted and is actually only considering the game client at the expense of the entire software system. (It is also a struggle for me because the video game community appears littered with SEO grifters, and the real experts are very secretive (so different from open source on the web). That is okay because it is fun to synthesize DDD techniques into a new context. I think of game software as the entire system and not just the game client. That means any backend or infrastructure is a piece of the complex whole. DDD for backend systems is well understood. The difference is it needs to serve game clients as well as any other clients (e.g. a website to market the game, forums for game related posting, maybe even run logic for chatbot(s)). If you want to expose online services to your game client, the backend system is where you will want to think about what logic to run and what state to persist. I like DDD for some categories of game client code, not all. There are some simple gameplay elements that are driven from game engine physics and collisions. There are more complex gameplay elements that benefit from more complex domain modeling techniques. Basically allow yourself to write untested/lightly tests components for simple gameplay elements. For complex systems, it may be beneficial to think of unity as concrete implementations for domain specific logic. Model the code in the language of the game system expert and think about how to translate unity runtime events (user input, collisions) into terms meaningful for the domain. In practical terms, unity game objects represent domain entities and interactions between game objects can trigger domain logic. For example, a projectile game object colliding with a combatant game object is a good place to execute combat service logic, which may trigger domain events (observable behavior) that can then be listened for by subscribers (e.g. a damage UI, a toast notification, or any other unity UI). This is turning into more of a brain dump but I wanted to send this out into the world since it’s a topic I’m studying heavily right now. Does anyone have more experience applying DDD to video games out there?
- deleted 5y ago[deleted]
- LennyWhiteJr 5y agoSeeing a lot of hate for DDD here so let me offer an alternative point of view from someone who advocated for DDD on my team. When I joined, my team had been building the backend for the first version of our app for about 4 months. I would describe the state of the code base when I joined as an 'Anemic Domain Model' as defined by Martin Fowler - There was a 'domain model' in the loosest possible sense - Each model type was just a POJO with raw getters/setters for each field - Almost all fields were primitives (mostly strings with a few int/doubles/dates) - All validation code for these types was done in application code and was fragmented throughout the code base - Internal DB identifiers were fully exposed into the code model - Internal service types were liberally mixed with external service types - No notion of aggregate roots - every entity was just accessed ad-hoc It was a highly unsustainable approach, and one of the first thing I did was attempt to implement strategic DDD in the areas that were the most painful. This included - Adopting rich value objects to represent domain concepts instead of raw strings - Enforcing business invariants inside the model classes - Enriching the domain entities with methods that matched business behavior and performed validation - Creation of repositories that shifted much of the persistence details out of the application code - Defining aggregates based on our required access patterns which simplified our data access - Bounded contexts for our internal domain - mapping external service types to our own internal representation The result of all this was the creation of a core 'domain model' that captured business behavior expected of our service and most importantly, ended up significantly simplifying the rest of the application code. If DDD makes your app code more complex, you're doing something wrong.
- stepbeek 5y agoThis sounds like another data point of many in this thread that point towards DDD as a philosophy working very well, while enforcing technical techniques advocated for in the book being hit-or-miss. This makes intuitive sense to me: it’s much easier to define a principle that applies in many situations but much harder to define concrete technical implementations that do. In your situation it sounds like the multiplier you applied was in pushing your team towards a rich domain. That’s a much more sensible approach than, say, using CQRS everywhere.
- mixmastamyk 5y ago
- alex_zim 5y agoAs anything else, a blind application of a technique, paradigm, or pattern, could be horrific. It doesn't matter what combination of capital letters is used. I've done horrific things when I was "doing DDD", until I realised how simple and elegant domain models could be when done right. Forcing people to do something they aren't used to and expect decent results is disastrous in any industry. It's just in software everything can be "refactored" so we are more easy-going with those things. With DDD "done right" there's no issue with understanding what the code does because it's split into tons of files. It's actually the opposite. But, indeed, it could be a nightmare when applied blindly, or forcibly because of some ivory-tower architect decided to "use DDD" without even knowing what it is. I know as I've been that guy.
- bob1029 5y agoYet another overloaded tech buzzword. For me, DDD means 2 things: 1. Listen to how your customer refers to their business and internalize this perspective as if your life depends on it (your career certainly may). 2. Find a way to build your product and communicate about it in similar terms. The methodology should be understood to be domain-specific. Anything that extends the philosophy beyond these points is making assumptions about your product that really only you and your customers should be making. The only concrete technical assumption I would make here is that you probably want to at least consider SQL for a few minutes if you are dealing with tons of distinct types and complex, rapidly-changing requirements from the business. If you can find a way to make the business write their own logic/queries in a language they understand, you have discovered the most powerful force multiplier I am personally aware of right now.
- cowanon22 5y agoIn my experience the most useful part of DDD is to have a common vocabulary for your projects - developers and end users should have some common terminology. For complex business domains it is good to have a glossary, and for your code to always use those words in the same way the business uses them. Other than that, most DDD concepts are a bit dated, and really oriented around JAVA/C# in the early 2000s.