Built to last: A domain-driven approach to beautiful systems

Video in TIB AV-Portal: Built to last: A domain-driven approach to beautiful systems

Formal Metadata

Built to last: A domain-driven approach to beautiful systems
Title of Series
Part Number
Number of Parts
CC Attribution - ShareAlike 3.0 Unported:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this license.
Release Date

Content Metadata

Subject Area
Help! Despite following refactoring patterns by the book, your aging codebase is messier than ever. If only you had a key architectural insight to cut through the noise. Today, we'll move beyond prescriptive recipes and learn how to run a Context Mapping exercise. This strategic design tool helps you discover domain-specific system boundaries, leading to highly-cohesive and loosely-coupled outcomes. With code samples from real production code, we'll look at a domain-oriented approach to organizing code in a Rails codebase, applying incremental refactoring steps to build stable, lasting systems!
Standard deviation GUI widget Military base Multiplication sign Software developer Real number Time travel Device driver Line (geometry) Flow separation Product (business) Frequency Mathematics Computer animation Summierbarkeit Row (database)
Complex (psychology) Suite (music) Existence Code Multiplication sign Modal logic Mereology Rule of inference Semantics (computer science) Formal language Product (business) Mathematics System programming Boundary value problem Software testing Error message Form (programming) Module (mathematics) Domain name Information Military base Software developer Debugger Expression Computer scientist Compiler Process (computing)
Module (mathematics) Scripting language Sensitivity analysis Dependent and independent variables Euler angles Decision theory Data storage device Product (business) Word Process (computing) Computer animation Software Alphabet (computer science) System programming output
Group action Multiplication sign Decision theory Cellular automaton Execution unit Plastikkarte Bit Primitive (album) Mereology Protein Product (business) Mathematics Software System programming Moving average
Complex (psychology) Trail Scheduling (computing) Computer animation Real number Order (biology) Boundary value problem System programming Bit Pattern language Entire function Computer architecture
Context awareness Group action Service (economics) Transportation theory (mathematics) Code Multiplication sign Device driver Disk read-and-write head Event horizon Formal language Product (business) Estimator Term (mathematics) Internetworking Hypermedia Software design pattern Core dump System programming Boundary value problem Diagram Information security Mathematical optimization Computer architecture Area Domain name Enterprise architecture Algorithm Texture mapping Software developer Weight Shared memory Electronic mailing list Plastikkarte Database transaction Entire function Word Process (computing) Computer animation Right angle Pattern language Routing Row (database)
Domain name Arithmetic mean Computer animation Gene cluster Electronic mailing list Diagram
Module (mathematics) Domain name Multiplication Context awareness Code Namespace Information overload Multiplication sign Connectivity (graph theory) Bit Cartesian coordinate system Mereology Product (business) Formal language Arithmetic mean Computer animation Thermodynamisches System Software Term (mathematics) Boundary value problem System programming Social class
Context awareness Multiplication sign Decision theory Database transaction Computer animation Software Term (mathematics) Scalar field Matrix (mathematics) System programming Quicksort Telematik Near-ring Social class
Context awareness Service (economics) Computer animation Code Electronic program guide System programming Bit Cloud computing Diagram Database transaction
Domain name Email Service (economics) ACID Plastikkarte Bit System call Product (business) Process (computing) System programming Diagram Circle Right angle
Context awareness Message passing Service (economics) Computer animation Direction (geometry) Source code System programming Musical ensemble
Domain name Context awareness Product (business)
Domain name Context awareness Service (economics) Code Multiplication sign Database transaction Bit Flow separation System call Product (business) Software Ideal (ethics) System programming Code refactoring Musical ensemble Computer architecture
Domain name Game controller Service (economics) Code Direction (geometry) View (database) Shared memory Cartesian coordinate system Product (business) Root Energy level Spacetime Social class
Domain name Computer animation Interactive television Object (grammar) God Row (database) Product (business)
Domain name Point (geometry) Dataflow Multiplication Graph (mathematics) Service (economics) Interface (computing) Multiplication sign ACID 1 (number) Device driver Product (business) Web 2.0 Arithmetic mean Data model Mathematics Process (computing) Computer animation Root Logic Object (grammar) Extension (kinesiology) Resultant Computer worm
Domain name Service (economics) Stress (mechanics) Sound effect Device driver Event horizon Medical imaging Data model Computer animation Query language Network topology Object (grammar) Row (database)
Domain name Computer animation Code Sound effect Analytic set Computer architecture
Domain name Message passing Computer animation Code Cartesian coordinate system Semantics (computer science) Event horizon
Domain name Curve Context awareness Game controller Service (economics) Wrapper (data mining) Sound effect Plastikkarte Database transaction Event horizon Formal language Latent heat Computer animation Object (grammar) Metropolitan area network Social class
Axiom of choice Message passing Process (computing) Computer animation Wrapper (data mining) Sound effect Software framework Resultant Computer architecture
Domain name Arithmetic mean Message passing Process (computing) Kernel (computing) Computer animation Personal digital assistant Shared memory System programming Spacetime Product (business) Library (computing)
Domain name Logical constant Dataflow Functional (mathematics) Context awareness Texture mapping Code Expression Semantics (computer science) Product (business) Formal language Data model Computer animation Repository (publishing) Data conversion
Domain name Axiom of choice Slide rule Dependent and independent variables Scaling (geometry) Regulator gene Keyboard shortcut Physical law Volume (thermodynamics) Mass Cartesian coordinate system Rule of inference Formal language Mathematics Arithmetic mean Word Computer animation Complex number Refraction System programming Pattern language Computer architecture
Point (geometry) Complex (psychology) Presentation of a group Context awareness Service (economics) Multiplication sign Modal logic Twitter Formal language Mathematics Strategy game Bit rate System programming Code refactoring Data conversion God Domain name Texture mapping Information Shared memory Volume (thermodynamics) Arithmetic mean Word Process (computing) Computer animation Personal digital assistant Network topology Factory (trading post) Self-organization Summierbarkeit Pattern language Object (grammar) Abstraction
some of the stars of 0 there are and looking for you welcome to your 1st day the law and you're no 1 in here now here at the lorry were revolutionising the industry of time travel with 1 puts a button on our you're going to be at the sum a driver and the morning who come roaring around the corner jumping get to whatever time period you want to now I 0 by the way I might mentions use a little bit messy because you got a lot of teams here you know so you might be a little surprising over the canvas but don't worry and is totally normal for everyone if you will that surprising 1st joint but 1 thing you should also know is that we have several these good bases so when you come to featured enacted check out this could this now and that 1 that 1 the and not only that we have so for the naming conventions around here the so when a product on a tells you about that is being widget don't forget it's actually called the the body in Haiti and that would someone actually called the body being the barber for some reason but don't worry about it is just the way things are right here to and now we're thinking of people we need to really clean things over here which I'm sure I promise you we're going to get around to but for the time being I I just really need you to be really heads down on our biggest waiters product development to not be deliveries like used in it the well it is member Standards all see around I noticed I wouldn't change welcome to the line I I mean and you in a month uh suffered evolve record 5 and like many of you have been a real devolver for several years and I come by
having been prior knowledge but jobs in the past i've all been a part of a team that works on large code bases in rules that have struggled to really scale as a growing in size and complexity
now I've been thinking a lot about beautiful systems where where things that make a system beautiful with talk a lot about you know about that beauty here reals strong so beauty as many of us reviews might think that comes from the language In its syntax in its form in its expressiveness whether we have Nice DSLs I read like English or it could come from the tooling developer ergonomics with beautiful II error messages that are very helpful or have an amazing debugger or if you're in a different language it could come from a great type system or a compiler it some us might consider beauty to come in the form of text where Archie community it encourages us to where great tests so where there is that the existence of a test suite that makes our code resistance to breaking changes but what 1 I 1 and proposed to us today is that system is beautiful when it's built to last when it has longevity in its stand the test of time with changing business in product requirements these long-lasting systems are just large enough they know their boundaries they don't grow past them they know what they're responsible for they are highly cohesive and loosely coupled in what that means is that they contain the necessary set of concepts within themselves and out in these concepts are all close together no need to reach outside to actually go fetch a concept somewhere else In recent loosely coupling in that they minimize the dependencies on just and they have pressed precise semantics that fully expressed the business domain so that when you jump into the could there's no confusion as to what it means as to what business process it's representing were attractive now some code is an ion for the past couple years so I've been reading papers from computer scientists in the past and we came across Indian choruses paper of from 1972 in which he wrote on the criteria to be used in decomposing systems into modules and I he called this criteria information hiding here's what it said he
compared the 8 software system its job was to process text in its attitude in input of words in it basically um at did some processing on the text in a shifted things in alphabet alphabetized things and he compared to approaches in which he train these systems into models so in the 1st step he treated the program like like a script in the sense that 1 goes into a model sensitivity model step 3 goes into a model in a sense that that's probably the approach that most people would have taken with this program but in the other approach he divided up by responsibilities so he said but this module is responsible for wine storage this module is responsible for alphabetizing this model is responsible for writing things at the desk and what might seem obvious to us 45 years later is
that this is a good idea and so when he concluded in the paper was that we divide up models typical design decisions or design decisions which are unlikely to change and by doing that we enslave these models from affecting the rest of the system when they change so I want to bring this
out and draw the cell a little bit more because I thought this applied very well to software systems from winning systems in our business where are the design decisions that are gonna change in our company wanna put forth and this happens within the business groups then generate these changes here is an example with my team 1 marketing wants us to generate 5 thousand primitives now on your team finance was unit when a new eidolon every time letters of credit card and on your team product once implement the delivery and then on 19 marking says 0 actually we want to thousand of those prop up by thousand using invalidated and then finance me just add yet another actin to the log your protein wanted you now want 2nd market and to the themselves like change divided up from the parts the business that are driving them
so if we never worked in a nice and rolled note deals with edge so marketing asses do this finance answers to do that and I am yeah like it's easy to add features as it gets spread across the the but as time wears on we know it feels
a little bit more like this and so the question
now becomes how we get out of this large system is doing too much stuff well I heard about micro-services and I know that they're not easy it is anything that I've learned from attending any these conferences is that they come with in operational complexity than most people that have that have failed to consider in realize only too late after stepping in how much do we extract do I extract like 1 little feature track entire in base In where schedulers boundaries I extract something that's too specific and then on the other hand would like extract something that's too generic I was more data and real something very large reals 1 and um we realized the interacting we needed to show something until about like where we want to take the architecture will we had no idea what do know from needed in the and and you like something on the order of 10 systems for the 90's I don't know if only we had something to help us visualize what we need well In 2003 Eric Evans other patterns can out the book called domain-driven design a hand in it
and I are both a set of high-level strategic design activities in also very concrete software patterns I must also warn you there's a lot of enterprise speaking it job occurred or . Nico you find on the internet that will be very confusing which certainly confuse me when I 1st got my head into it but my coworker told me at the time you should really look into doing your design is I think and will hold us so today what we're gonna do is we're gonna pick an activity from demeanor resigned called building a context In this through the context not wearing it learns some but some concepts from domain-driven design that will help us understand our systems and then Elise refactoring patterns that we can then apply to incrementally organize your systems around the boundaries that will find out of context so let's get started domain-driven design is very very much focused on language that's the 1st the station and that I usually tell people when ask about the subject and in the language of we have something called a ubiquitous language and ubiquitous language is not so it's not meant to be a global language for the entire company use but it's simply a share set of terms and definitions that your team in your area of the business can agree on and we typically use this language to drive the design of the system so through the development of something called the glossary we get people together in a room and we simply get together in the right out was termed the definitions this is a very elusive anniversary for exercise so we simply come up with nouns and verbs that we use in our domain or within a team so for example over lunch we might sit together and when I might work OK will a driver is this the the driver of the lorry in the driver drives lies Trevor services the writer does this in your product or ID like weight we call it a passenger a new scribble our irony right all action of wouldn't say passengers the In my talk about events as of verbs so there might be an event in which we heal a driver for Namibian than 1 charge a credit card and so on and so forth and the idea is that this term of up with this list of terms and definitions is something that we codify from either a document or in the code so that we can all be in agreement about what words to use and then we go on and we certainly meaning things in the code to follow the business domain so for example we might have something in which we have a user requesting each now there's 2 this to English things in here that we realized don't actually follow this estimate so it's actually a passenger in passenger the driver knows move on in Moscow visualize our system a minimal generating earity diagram for us in and there are jammed that do this for us 1 of which is called real ready and once called real security and simply the going house to get a lady the land of the architecture of the system using activity relationships to try these relationships so here's when
something like that might look like but it's a little hard to read very arena we will build the donor right I don't work for us but most likely if your company has a very large base you're the science can be gigantic but we once printed hours added our company and was media like 60 long pronominal papers in most likely schema gigantic in and Mary not actually usable it is not usable you may have a general 1 by by hand or something so I was struck by that by defining a few core concepts come around domains the the domain of your business speak or domain is the thing that makes the business do what it does uniquely to the business so add the warning Our core domain is transportation if you're Google your core domain would be search if you were flickering recording would be photo-sharing and then there are things known as supporting the supporting domains are simply areas of business that support that play supporting roles to make the core mean happens so here the war and we what we have attained that's the buddhist drive around In all they do is they come up with maps and fancy algorithms to rout the driver the workplace or we have a domain of for financial transactions in which the charge you credit cards or repay the drivers and then we have the optimization team that tracks business events and makes recommendations to the rest of this is on how to optimize certain business processes and we have a customer support team which manages user ticket and he people have Genoa India's Ringo discover
these domains by using the diagram to help us think so when I look for clusters on a diagram and we might discover a means we haven't thought about so
tha the we take a look here and there may or may not be clusters that pop out at you I do work for us here but and so I have come up with this but as a team you might come up together because of exercise most likely it will not be as clean as 5 figuring it out to be here but for the sake of illustration let's go this so now we've had a list of the
means and system and we have a rough idea on what models belong which domains now as topic boundaries because boundaries are important concept that will help us divided versus now in the are rails out on their behalf to we might have a boundary of a class the class is the definition for a certain concept but it's a concrete in code and and it's meant to be a single the boundary on 1 concept in module can be a boundary across a collection concepts it simply a name space for multiple classes the within or something the and Jens are another way to package up code that that belongs together and should it around and then finally I things like Rails engines Wells applications extra applications external API eyes can also be boundaries upon which other concepts are contained so down
context is simply a software system so when I put it out there and I say that context today I will simply mean in the pointing suffer systems somewhere in production or it could be a suffer system that could be 1 within your business but since this is the main design there's a language component to it so linguistically it's actually a uh of a part of a domain in which concepts live and um are bounded in their applicability so what that means might think about it of the as a playground for concept to live but do not allowed outside but and I'm going to spend a little bit time explaining these little bit more the bounded context allows us to have precise language because it allows us to have terms that have conflicting overload in terms of of it lets us separate them and give them their own playgrounds to honor around and here's an example we have
each request and to us a trip is simply the of the thing that that a new passenger digital car and they they go they go for it so that the trip and there's a time there's a cost matrix
however it's a little overloaded in the financial transaction world but concept that trip time is when the goal is moving in a in a finance department are like they just made the decision that were not in charge the car were not in terms of customer when the car is stopped I don't know that means when you're time-traveling but very near trip time in the routing context is calculated when the passengers in the car no matter whether the cars moving stock so you can see right here is that depending on what context you're in the business whatever software systems using them there's no answers in behavior missing context but or would then trip costs how much money is there uh custody charged that's what cost means in finance but when you go to the running the trip class is actually a completely different terms it's some made up metric for as trip efficiencies some sort of scalar so those 2 concepts have similar names but wildly different the actual definitions so what we do well if
you're like the what we when they're in the past is we might simply just made a little bit more specific and then we would just like to close the bottle and what away and then what we've done here now is that engineers in the code will actually have to understand the nuances of these methods and understand what is meant to be used in this context as in these in that context
just briefly here the we can fix this by introducing 2 down contexts there could be a trip that belongs to the financial transaction down context in another 1 for the routing context Boden's that little bit later so here's what already willing to go find the boundaries of within our existing system using then diagram of the guide so will also keep in mind that there are other systems in the landscape of our business so things like other team services or other cloud providers so over here I've
started out with the diagram pull out your the behind it just make it more clear and draw the circle around what I know Jesus model here is the monorail at and I thought a little bit more
about it and I realize that your team has the e-mail service and all we actually use are in AWS service call as an acid send this notifications to people's bones news Braintree to church credit cards and actually in the process of drawing up these other systems actually realized this and other domains that haven't thought about yet so on the right and so personifications domain thought about and is there's a marketing because marketing sense targeted e-mails to people and then finally I wanna
drive dependencies between these band context
so that I'm connecting these context and then I'm drawing I a running you already used as for upstream the D. Since the downstream what that means is that the unstrained system is a system that is the source of truth for certain types of data so I'm at the upstream system may provide EPI the upstream system the fire the message whereas if you're the downstream systems you are consuming more you are dependent on whatever the utterance service provides In drying armies directionality dependencies will actually help us understand the labeling and to understand the relationship our system has with other systems some In the world of our business you might notice a few things a few things
about the context not but my notice that 1 bounding context has multiple supporting domains so this is a very intuitive to many of us because we felt the pain the model model of did too much because in this trying to manage the these different means the another thing I notice is that there's multiple bounded context the have to support a single domain so over here we notice
that financial transactions and customer both spans several software systems this is kind of a call out to us make us realize that if we ever have to in when a feature in any of these domains were have been up touching a few the systems and then in the end of the there
is an ideal or a suggested outcome that DDT suggest to us that every domain is matched up with his own band context so this might look something like this and this is certainly not that if the we a practical architecture for many of us but if we took into the strain every domain would have its own software system learning behind it you might also imagine this to be maybe the ideal like a service architecture when I said that I was really want to go back but the idea is that everything is segregated to be highly cohesive of within itself OK now we get to the actual code so when we will begin our 1st refactor instead the only 1 I change a little bit of things at a time so when they do now is a draw out 1 domain and make a model so let's say I'm going when a feature somewhere sharing in while I touch those features and actually bring in some of those concepts into originally
so I start with the end of the model and engagement classes and the model and introduce the sharing model and then I have to do the real the things to get the rest of the application understanding that this thing is known in space now I'm going to go move that
code into a new folder I've nominated a um a 2nd level folder called domains and then within that on a certain you folder for every single model of introduced so we hear me direction and I'm basically just dumping in and all the code that collected from my models a controllers my views or maybe even my services and the idea is to move all I could that's related together into their own folders this will temporarily make that right shameful their little messy but I wanna put for that it's OK in in the interim never something also called aggregate roots and the the idea behind this is that of in and there
were helps us to address the problem of God objects in active inactive records so we often kinds of objects and know too much about the outside world oriented Wilson is too much about our object to so over here we
have an active record model that might be explicitly bound 2 other models in interaction domain In this painting confirmation as I've
illustrated here has a lot of relationships that may not be necessary but however the fact that they're all explicitly defined here makes it difficult to refactor Mr. harder right tests but and it's just kind of off work at
additionally outside actors may actually know a lot about the internals of minor mean so I might have flow that's a web you UI that that calls in in like it up it's all these models where I have an extra only till process that ones mainly in extensions as well what's on Monday mean or I might have a thing that pushes the person of occasions drivers in acid leach into vitamin and so the idea of an aggregate roots is something that we it is the idea that I'm gonna expose only a single on graph of objects to the outside world so simplify when exposed to the outside world so that the outside world and has a reliable interface into my data models and protect my internal their models from being a but from change so over here I've decided you know my trip is going to be the root and then the aggregated is going to be all these other models that flow out from the trip and the idea here is
that this trip now the well expose everything else but only to itself and so any time someone makes a direct method called to me evidence on an someone so it asks for the trip I'm mowing exposed aggregate root you do some payload you EPI and point you might have multiple aggregate roots per domain which is OK on but just expose just enough to the outside world certainly makes sense but now here's a quick that thing that we can do we can build a service logic that will provide this aggregate root so the idea is that I'm in is a result of that will create a aggregate Rubetta's is basically a 4 side so here's
images of being called effect stress In this picture essentially is the rap Over
here bringing as an actor record query s simply returns of passengers and drivers on top of the tree but alternatively could be as or someone that just something to to have dated aspect of the of the world and now I'm callers in which used to be tied to my domain through Active Record relationships when are simply called the service object this service or that will then return to them the related data model that they need finally let's talk about an event
driven architectures tha
in the past we might have had to of go somewhere else to do a side effect after we finished processing code in our domain so over here when a trip is being created this code then reaches out in does something in unrelated to me which ends up coupling the 2 domains so over here you you
see that nice air Bereichen concern but then has it perform something the analytics that means well but if we flipped the data dependencies so instead
what we're going do is we're go publish and then and then we're going to go ahead the other domains subscribe to that the and so therefore we lower the coupling to domains I will now introduce a
thing so I'm essentially introducing a message bus and with this message by and introduce a publisher and rehab subscribers are handlers to handle these events and I'm doing this through a genome called whisper whisper provides publish-subscribe semantics 4 of the applications and so on so here the domain and then publisher simply passes through and then and and calls through whispered to publish and on the other side the so here in the original code instead of called reaching into the other domain understand fire the now I on the
other side every bounded context is now that an old or respond to this event depending on whether needs it or not these handlers will also use things called command objects to basically perform decided that so over here
I to make domain and then handler this domain event handler will listen to the trip created event during the year through the definition of a class method culture created and so therefore and every times in external a publisher publishers strip created this domain and then hammered that turns around and fires the long trip created man here's the blue curve in which whisper is set up to subscribe to events so the event handlers subscribing to events from the publisher and this is a the illustration of what the command object looks like the commander the simple language service wrapper around a specific side effect that has to happen might also see that other domains need to also respond to these events and so over here we're introducing some extra behaviors that at that depth of that is now the couple from the controller and so in a financial transaction world we would also do things like reading on a larger we did not get card announce etc etc so this
is kind of the end result of a new architecture from where we introduce a method bus should also be noted that this is technically not a it message burst in the asynchronous manner yet whisper actually just uh has some nice wrappers that allow you to make it look like it's amazing but it's actually still synchronous and love quest until you introduce the
active job wrapper and now your handlers will now be queued of as an actin jobs and so this allows you to actually make your your side effects asynchronous with your at the durable worker Q framework of choice like psychic for rescue and then I
choose a glucose to make that happen with that job
while you can also a real message so if you actually did cover assistance to other external systems you might introduce a thing 1 rather than q and there's a few nice gentle lady that has just fix has a nice 1 called Hugo is also again called sneakers to a such about a couple of more advanced topics the 1st 1 of which is and what happens when we want to share models between domains let's say I have a system that's off your nervous system here but they actually saw to access the same data well there's a there's a concept called a shared kernel in which we simply like we make it OK to ship around a certain share package and so what what I suggest that cases we simply need space from models under that shared meaning space In this can actually come gender the activation the 2 extra library enough but I would also say that if you find a so sharing a lot in Europe maybe not thinking that get domain clearly enough because there might be In actual thing that you want you which are at about next is when you have 1 model that actually
use the belonging to remains sometimes you have a concept that just has to be broken up and how can you get these constants codified within their respective domains now there's something called an anti-corruption where which I will introduce which is simply an adapter that maps a concept from the outside world into a concept that we can use within our domain so here's an example from
so remember that trip that I introduced earlier on well we know that it actually has the semantics for T domains so what if I introduced the nice very expressive domain model for the routing context here so over here and that's a really beautiful them a model that has the language that we use flows nicely matches this is mean and when I'm in do is I'm minimaker adapter that simply maps of maps from that legacy data model into or internal so there is simply a mapping function that just maps things together and any any converts instantiates art curator mean model internal and then you were to add a repository in which we as simply grab thing from the outside and then we need station and after it which converts us to the interval in out internal main code is going to call repository assertive directly reaching for the outside world aside happens
next so 1 would imagine
that but you can apply this incrementally so the beauty of this is that you can apply 1 or a few or maybe all the refraction patterns a new minor things 1st into incremental that domain-oriented folders so you might simply pick and choose new things and dropping the folders next we can use you could turn this folder into rules engine so they're actually self-contained applications and the next you can do is actually just into that of their own rail services and then finally you can into whatever I language or whatever it you use of your choice and the idea here is that actually as you continue decoupling these things you allow your systems and your teams to scale because the to actually be able to 1 in isolation from each other and slowly but surely but I wanna drop a few cardiacs because this happens had to be there to the DVD will work very well for you it once you have a complex domain we need the linguistic precision define herself really caught upper tripping up over words remains a means or you may be your business is just very complicated you have a lot of regulation in your domain or something that's a lot of new answers to me 2nd volume might work very large changes might have a NASA team working on a mass of this so this might actually help you isolate the systems law 3rd year open to experimentation yeah binding on and forth the whole team is willing to try it out including other teams so if you're in a lone wolf that was slide this under the door this is not gonna work you need have Bayern Munich The have agreement that hate when trial this new this new architecture which had a few of these refactoring steps how does it feel it is it is the fuel that need have 2nd thoughts or somebody's really against this may not work this is in response
to a presentation I gave earlier on there was a conversation on Twitter in so said hey you're just doing China and then I had this thought like 0 my god like are we becoming the thing we hate just actually of a lot what the job but I would say that in Ruby on Rails we often times have this search we were on this quest for simplicity but that may not necessarily be the best thing in every case because in domains where the sum necessary and essential complexity maybe we can be searching for is clarity and
so then mind on a share with you something is I to be on the watch for it it doesn't feel right when he stopped so hopefully you've been applying these incremental risk factors but at a certain point you might feel like rate I feel like over design I feel like there's a little too much going on here where feels like it's kind of silly just to make this thing to do that thing and so this thing the here 2nd volume I feel like maintains abstractions is kind of a word you're just you're just like doing things just for the sake of following the patterns of the book it actually might be OK to simplify things 2 instead of creating a Puritan meaning of the is on creating an like a service that does this to and after that this to this other past tree we might be able to get away by smashing those 3 things together into 1 object and the column day it's OK and finally if other changes silently crumbling or they're not such they're they're very obviously grumbling about it then maybe it's maybe it's time to start having conversations it's OK you don't have to follow this by the book once again the beauty of this once again is that we the incrementally factory incrementally apply things so in summary we discovered the domains their business we in develop a shared language with their business we build a context map and so we saw some strategic insight and saw the label and and finally we found some refactoring patterns In some organizations strategies to help us organize accommodations to hopefully get us to the next step so we can build our system that will scale In without making it real score for inviting me here appears on it uh contact information and if we if you'd like to talk about the topic you afterwards than here thank you very much but this fewer
and the SHS and are