Merken

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

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
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
Domain <Netzwerk>
Gewichtete Summe
Mathematisierung
Biprodukt
Zeitreise
Frequenz
Computeranimation
Systemprogrammierung
Datensatz
Druckertreiber
Reelle Zahl
Widget
Ablöseblase
Stützpunkt <Mathematik>
Softwareentwickler
Gerade
Standardabweichung
Domain <Netzwerk>
Formale Semantik
Prozess <Physik>
Compiler
Formale Sprache
Mathematisierung
Komplex <Algebra>
Code
Formale Semantik
Systemprogrammierung
Domain-Name
Bildschirmmaske
Arithmetischer Ausdruck
Softwaretest
Modul <Datentyp>
Geschlossenes System
Prozess <Informatik>
Informatiker
Existenzsatz
Datentyp
Stützpunkt <Mathematik>
Biprodukt
Softwareentwickler
Softwaretest
Suite <Programmpaket>
Geschlossenes System
Softwareentwickler
Schlussregel
Biprodukt
Modul
Modallogik
Menge
Formale Sprache
Debugging
Mereologie
Information
Geheimnisprinzip
Fehlermeldung
Sensitivitätsanalyse
Prozess <Physik>
Zeichenvorrat
Euler-Winkel
E-Mail
Ein-Ausgabe
Modul
Computeranimation
Entscheidungstheorie
Entscheidungstheorie
Systemprogrammierung
Modul <Datentyp>
Geschlossenes System
Einheit <Mathematik>
Software
Prozess <Informatik>
Endogene Variable
Skript <Programm>
Wort <Informatik>
Modelltheorie
Speicher <Informatik>
Modul
Bit
Mathematisierung
Gruppenkeim
Zellularer Automat
Dienst <Informatik>
Entscheidungstheorie
Systemprogrammierung
Einheit <Mathematik>
Geschlossenes System
Software
Gruppentheorie
Gamecontroller
Code
Primitive <Informatik>
Biprodukt
Gleitendes Mittel
Geschlossenes System
Anwendungsspezifischer Prozessor
Biprodukt
Sichtenkonzept
Chipkarte
Entscheidungstheorie
Software
Mereologie
Ganze Funktion
Attributierte Grammatik
Modelltheorie
Scheduling
Weg <Topologie>
Bit
Geschlossenes System
Reelle Zahl
Generizität
Mustersprache
Dienst <Informatik>
Ordnung <Mathematik>
Unternehmensarchitektur
Ganze Funktion
Komplex <Algebra>
Computeranimation
Chipkarte
Domain <Netzwerk>
Prozess <Physik>
Gemeinsamer Speicher
Weg <Topologie>
Minimierung
Formale Sprache
Computeranimation
Internetworking
Algorithmus
Geschlossenes System
Prozess <Informatik>
Code
Mustersprache
Speicherabzug
Druckertreiber
Geschlossenes System
Computersicherheit
Stichprobe
Entwurfsmuster
Globale Optimierung
Biprodukt
Kontextbezogenes System
Ereignishorizont
Gruppenoperation
Dienst <Informatik>
Transaktionsverwaltung
Software
Menge
Rechter Winkel
Eindeutigkeit
Gewicht <Mathematik>
Gruppenoperation
Diagramm
Dienst <Informatik>
Term
Transportproblem
Code
Kontextbezogenes System
Textur-Mapping
Systemprogrammierung
Domain-Name
Datensatz
Softwareentwickler
Ereignishorizont
Ganze Funktion
Transaktionsverwaltung
Schreib-Lese-Kopf
Schätzwert
Transportproblem
Linienelement
Mailing-Liste
Routing
Chipkarte
Diagramm
Druckertreiber
Flächeninhalt
Formale Sprache
Hypermedia
Wort <Informatik>
Speicherabzug
Unternehmensarchitektur
Term
Stab
Shape <Informatik>
Arithmetisches Mittel
Domain <Netzwerk>
Diagramm
Domain-Name
Diagramm
Mailing-Liste
Identitätsverwaltung
Cluster <Rechnernetz>
Transaktionsverwaltung
Computeranimation
Bit
Overloading <Informatik>
Domain <Netzwerk>
Klasse <Mathematik>
Formale Sprache
Kartesische Koordinaten
Textur-Mapping
Term
Kontextbezogenes System
Code
Computeranimation
Font
Multiplikation
Domain-Name
Geschlossenes System
Modul <Datentyp>
Software
Modelltheorie
Namensraum
Geschlossenes System
Objektklasse
Kontextbezogenes System
Biprodukt
Modul
Overloading <Informatik>
Arithmetisches Mittel
Software
Formale Sprache
Komponente <Software>
Mereologie
Modelltheorie
Term
Inklusion <Mathematik>
Matrizenrechnung
Klasse <Mathematik>
Kontextbezogenes System
Fastring
Term
Kontextbezogenes System
Quick-Sort
Skalarfeld
Computeranimation
Overloading <Informatik>
Entscheidungstheorie
Transaktionsverwaltung
Geschlossenes System
Software
Telematik
Skalarfeld
Transaktionsverwaltung
Streuungsdiagramm
Overlay-Netz
Bit
Geschlossenes System
Dienst <Informatik>
Kontextbezogenes System
Cloud Computing
Gerade
Code
Computeranimation
Systemprogrammierung
Transaktionsverwaltung
Diagramm
Dienst <Informatik>
Software
Geschlossenes System
Elektronischer Programmführer
Transaktionsverwaltung
Bit
Kreisfläche
Prozess <Physik>
Atomarität <Informatik>
Systemaufruf
Chipkarte
Diagramm
Domain-Name
Dienst <Informatik>
Geschlossenes System
Rechter Winkel
Routing
Modelltheorie
Druckertreiber
E-Mail
Transaktionsverwaltung
Dienst <Informatik>
Geschlossenes System
Gruppe <Mathematik>
Datentyp
Richtung
Routing
Quellcode
Kontextbezogenes System
Gerade
Message-Passing
Computeranimation
Richtung
Domain <Netzwerk>
Geschlossenes System
Domain-Name
Raum-Zeit
Modelltheorie
Kontextbezogenes System
Kontextbezogenes System
Domain <Netzwerk>
Bit
Kontrollstruktur
Systemaufruf
Ideal <Mathematik>
Kontextbezogenes System
Kontextbezogenes System
Code
Unternehmensarchitektur
Dienst <Informatik>
Domain-Name
Transaktionsverwaltung
Modul <Datentyp>
Geschlossenes System
Software
Gruppe <Mathematik>
Ablöseblase
Routing
Modelltheorie
Refactoring
Ideal <Mathematik>
Unternehmensarchitektur
Modul
Domain <Netzwerk>
Sichtenkonzept
Kontrolltheorie
Gemeinsamer Speicher
Klasse <Mathematik>
IRIS-T
Kartesische Koordinaten
Objektklasse
Raum-Zeit
Code
Übergang
Richtung
Domain-Name
Dienst <Informatik>
Gamecontroller
Restklasse
Wurzel <Mathematik>
Modelltheorie
Druckertreiber
Objekt <Kategorie>
Datensatz
Objekt <Kategorie>
Domain-Name
Datensatz
Ganze Funktion
Grundsätze ordnungsmäßiger Datenverarbeitung
Interaktives Fernsehen
Modelltheorie
Computeranimation
Objekt <Kategorie>
Resultante
Domain <Netzwerk>
Prozess <Physik>
Punkt
Kontrollstruktur
Atomarität <Informatik>
Mathematisierung
Mathematische Logik
Computeranimation
Eins
Open Source
Graph
Benutzerbeteiligung
Domain-Name
Multiplikation
Wurzel <Mathematik>
Modelltheorie
Maßerweiterung
Druckertreiber
Schnittstelle
Prinzip der gleichmäßigen Beschränktheit
Gerichtete Menge
Graph
Datenmodell
Wurm <Informatik>
Datenfluss
Systemaufruf
Arithmetisches Mittel
Objekt <Kategorie>
Dienst <Informatik>
Druckertreiber
Wurzel <Mathematik>
Modelltheorie
Soundverarbeitung
Domain <Netzwerk>
Datenmodell
Abfrage
Objektklasse
Ereignishorizont
Computeranimation
Objekt <Kategorie>
Netzwerktopologie
Datensatz
Domain-Name
Dienst <Informatik>
Druckertreiber
Normalspannung
Bildgebendes Verfahren
Soundverarbeitung
Domain-Name
Analytische Menge
Ereignishorizont
Unternehmensarchitektur
Code
Computeranimation
Domain <Netzwerk>
Domain-Name
Kartesische Koordinaten
Objektklasse
Ereignishorizont
Code
Message-Passing
Ereignishorizont
Computeranimation
Formale Semantik
Soundverarbeitung
Umwandlungsenthalpie
Domain <Netzwerk>
Kontrolltheorie
Formale Sprache
Klasse <Mathematik>
Soundverarbeitung
Kontextbezogenes System
Systemaufruf
Kontextbezogenes System
Ereignishorizont
Computeranimation
Chipkarte
Objekt <Kategorie>
Transaktionsverwaltung
Domain-Name
Dienst <Informatik>
Wrapper <Programmierung>
Kurvenanpassung
Ereignishorizont
Metropolitan area network
Soundverarbeitung
Resultante
Thread
Prozess <Informatik>
Wrapper <Programmierung>
Ereignishorizont
Unternehmensarchitektur
Transaktionsverwaltung
Auswahlaxiom
Framework <Informatik>
Message-Passing
Computeranimation
Kernel <Informatik>
Domain <Netzwerk>
Gemeinsamer Speicher
Raum-Zeit
Namensraum
Raum-Zeit
Computeranimation
Kernel <Informatik>
Arithmetisches Mittel
Systemprogrammierung
Domain-Name
Message-Passing
Geschlossenes System
Prozess <Informatik>
Programmbibliothek
Notepad-Computer
Modelltheorie
Ereignishorizont
Message-Passing
Modul
Implementierung
Lineares Funktional
Domain <Netzwerk>
Umsetzung <Informatik>
Dokumentenserver
Formale Sprache
Datenmodell
Umsetzung <Informatik>
Kontextbezogenes System
Datenfluss
Code
Computeranimation
Formale Semantik
Konstante
Textur-Mapping
Domain-Name
Arithmetischer Ausdruck
Strebe
Routing
Modelltheorie
Modelltheorie
Modul
Domain <Netzwerk>
Mathematisierung
Formale Sprache
Spektralzerlegung <Physik>
Kartesische Koordinaten
Dienst <Informatik>
Gesetz <Physik>
Kontextbezogenes System
Computeranimation
Message-Passing
Domain-Name
Geschlossenes System
Endogene Variable
Mustersprache
Biprodukt
Spezifisches Volumen
Auswahlaxiom
Regulator <Mathematik>
Zentrische Streckung
Schnelltaste
Zeitabhängigkeit
Ruhmasse
Schlussregel
Rechenschieber
Arithmetisches Mittel
Komplexe Ebene
Refactoring
Wort <Informatik>
Modelltheorie
Unternehmensarchitektur
Domain <Netzwerk>
Umsetzung <Informatik>
Gewichtete Summe
Punkt
Gemeinsamer Speicher
Selbst organisierendes System
Mathematisierung
Formale Sprache
Twitter <Softwareplattform>
E-Mail
Abstraktionsebene
Kombinatorische Gruppentheorie
Komplex <Algebra>
Kontextbezogenes System
Computeranimation
Netzwerktopologie
Systemprogrammierung
Textur-Mapping
Domain-Name
Gewicht <Mathematik>
Geschlossenes System
Prozess <Informatik>
Mustersprache
Gasdruck
Spezifisches Volumen
Ruby on Rails
Abstraktionsebene
Kontextbezogenes System
Bitrate
Arithmetisches Mittel
Objekt <Kategorie>
Modallogik
Dienst <Informatik>
Twitter <Softwareplattform>
Grundsätze ordnungsmäßiger Datenverarbeitung
Strategisches Spiel
Faktor <Algebra>
Wort <Informatik>
Information
Modelltheorie
Refactoring
Shape <Informatik>
COM

Metadaten

Formale Metadaten

Titel Built to last: A domain-driven approach to beautiful systems
Serientitel RailsConf 2017
Teil 15
Anzahl der Teile 86
Autor Hao, Andrew
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/31235
Herausgeber Confreaks, LLC
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract 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!

Ähnliche Filme

Loading...