[2:55] put that in another but it was very
[2:59] convenient to start working because I
[3:01] can do that on my computer put some
[3:03] files on a folder run my application and
[3:05] thisif is moving so we starting working
[3:08] with the file system so we get unlocked
[3:10] and we starting adding features after
[3:13] one month they finally came with a
[3:17] protocol so they told us hey you will be
[3:21] using the FTP protocol so you can you
[3:24] know share files together the here are
[3:27] the credentials so you need to go back
[3:30] to the code one month's worth of code
[3:32] and everything you have done in that
[3:35] file with the file system you no need to
[3:37] use the FTP
[3:38] instead so I did that it was fine but
[3:43] then you can guess what happened they
[3:49] came back like two months in the project
[3:52] with the dead like coming there is no
[3:53] way we could move the deadline they came
[3:55] back and I say oops it won't be FTP like
[4:00] all the thing you have done that won't
[4:02] work you need to use HTTP not even HTTP
[4:06] HTTP so at that point what you should do
[4:11] you cannot move the deadline specs are
[4:14] changing that's life you should
[4:16] renegotiate the scope what's really
[4:19] important what needs to be done on the
[4:20] first of January so your application
[4:22] works this is what you need to negotiate
[4:25] and maybe there are some things we
[4:26] discussed we agreed on at the beginning
[4:28] but there are less important however in
[4:33] that case I went back to the code and
[4:36] like in an hour I actually was able to
[4:40] migrate everything from using FTP to use
[4:42] HTTP instead and I had no regression it
[4:46] was very easy for me to do that and not
[4:49] only that but since the very beginning I
[4:52] didn't even set up an FTP server on my
[4:55] machine and either I try to mock the
[4:58] other systems using HTTP to test my
[5:00] application well we're still using the
[5:03] file system on the development
[5:04] environments and then HTTP for the
[5:07] production and it's not because I'm a
[5:10] 10x developer or super coder or whatever
[5:13] it's because I know some tricks
[5:23] I want to tease you too much so I'm
[5:24] gonna give you right away the
[5:26] of this talk like that right at the
[5:27] beginning so if there is one thing you
[5:29] should retain from my talk today is this
[5:31] if you want to write a maintainable
[5:35] software there is one thing that is
[5:37] universally true that you should do
[5:39] which is first identify the domain part
[5:42] identify the infrastructure part and
[5:45] then you separate both of them this is
[5:48] critical so let me introduce these two
[5:52] terms my name is Nicolas I'm working in
[5:57] Montreal Canada for a nice company named
[6:00] buzz pod so at best but we do a web
[6:03] application for you to search compare
[6:05] and book intercity bus tickets meaning
[6:08] that if I want to go from Sofia to
[6:11] positive and I don't know Bulgaria
[6:13] because I'm a tourist I can still use my
[6:15] application and find a different kind of
[6:18] buses that they do find the best the
[6:20] cheapest one maybe or the fastest one
[6:22] and I can still pay in Canadian dollars
[6:24] or you can use that in travel to South
[6:27] America for example and pay in Euros or
[6:30] whatever currency you want every day at
[6:34] work we use some words so when we speak
[6:38] together developers project managers
[6:40] marketing people customer support people
[6:43] we share a vocabulary like we speak
[6:46] about seeds departures
[6:48] staffs round trips etc and we have the
[6:52] context around this word you probably
[6:54] don't understand leg the way we do in
[6:56] our context however taxes fees discount
[7:02] code that kind of thing you probably
[7:03] have that too if you're taking money
[7:07] from people if you are having a check
[7:09] out part in your application you
[7:11] probably have these words too regardless
[7:14] all of these words there are part of our
[7:17] business and we talk about these words
[7:19] regardless your developer or not this is
[7:22] your domain domain is or business and
[7:26] one could argue that this domain exists
[7:31] regardless there is a software or not
[7:33] you could imagine that we have a kiosk
[7:36] in every bus station in these 80
[7:38] countries with someone behind with
[7:41] you come see that person what are the
[7:43] best available oh you have all of these
[7:45] operators and here is the best one you
[7:48] pay money to us we get some commission
[7:50] and we make money now without software
[7:53] it will hardly be profitable that that
[7:56] won't be realistic software make the
[7:59] business profitable but it doesn't
[8:02] really matter what kind of technology we
[8:04] use behind for the cubes immersion here
[8:08] are some of the technologies that we use
[8:10] today so for example we store things
[8:13] into Redis and passe grid databases we
[8:16] could have used other kind of databases
[8:19] for example that doesn't really matter
[8:21] this is the infrastructure the
[8:24] infrastructure is what all of the tools
[8:27] that we have made together to make all
[8:31] of this work in real life but really the
[8:36] infrastructure part is a detail meaning
[8:39] that you can change it and it won't
[8:43] change the business this is something we
[8:47] miss Adam as developers we are here to
[8:50] solve the problem we're here to build
[8:52] the infrastructure to make the business
[8:54] work and because of that we focus too
[8:58] much on the solution and we tend to not
[9:01] speak that much about the problem that
[9:03] we're solving however at the heart of
[9:06] our software we are solving a business
[9:09] problem and it's important to keep that
[9:12] separation and to put the domain part at
[9:14] the heart of the software because this
[9:16] part won't change or when this part
[9:18] changes that means you're making your
[9:21] business grow let's see that on a
[9:25] concrete example so it's an example I
[9:29] really like which is let's imagine we're
[9:32] building a poetry as a service system
[9:34] and this is prince zero our project
[9:38] manager she is asking us to well as a
[9:41] user I should you know get a poem from a
[9:43] poetry library and if I don't get a poem
[9:46] you should return me the default one
[9:48] which is listed in the specifications so
[9:50] let's try to do that the
[9:54] usual way so if I was to do that and by
[10:04] the way I need to do a disclaimer these
[10:07] days since I'm at best but I mostly do
[10:09] JavaScript so my PHP is a bit rusty but
[10:12] the example is simple enough so you will
[10:14] follow so at some point I will create a
[10:17] class which I will call a poetry reader
[10:19] because yes it will read some poetry and
[10:21] this class it will have a public method
[10:24] which I will call give me some poetry
[10:26] because like I'm using the words that
[10:30] were in the specification sounds fine
[10:32] this thing should give me some poetry
[10:34] now where do I find the point so I ask
[10:39] the question this is print 0 there is
[10:41] some kind of author system that will be
[10:44] writing the poem somewhere on the file
[10:46] system in a text file so I should really
[10:49] just go and read the content of that
[10:51] text file and because this is vs code so
[10:55] you can see here it's a bit small but I
[10:58] do actually have a text file so this
[11:00] thing will work this thing will be
[11:03] located in my assets folder and if I
[11:07] don't have a poem well I should go use
[11:10] the default poem that we agreed on which
[11:13] is poem from Alastair Coburn who coined
[11:17] the exact normal architecture terms
[11:19] originally and then I returned that
[11:22] point okay I do I make this work well at
[11:28] some point I need to instantiate the
[11:29] poetry read your class and then I will
[11:34] just use my CLI here to see the result
[11:36] of that so I will echo quash reader give
[11:40] me some poetry okay let let's try that
[11:44] so I told you this is this is just a
[11:47] file nice so I get something it's a
[11:54] French poem but wait a minute because in
[11:57] French we have some accented characters
[12:00] and seems that we have an encoding
[12:02] problem my favorite kind of problem
[12:06] so yes there is this problem and we
[12:10] asked the project manager what's
[12:11] happening and turns out the the file
[12:14] we're receiving is not encoding using
[12:17] utf-8 so we need to you know convert the
[12:20] encoding and hopefully in PHP well we
[12:23] have a function for that so MB convert
[12:27] encoding give it the poem I want that in
[12:30] utf-8 and turns out the encoding use is
[12:34] a Western encoding whatever is a thing
[12:39] so let's try that again and here it is
[12:43] it works so classic short basic example
[12:49] of what it will look like to to develop
[12:51] that kind of feature traditionally we
[12:54] just go and solve the problem and make
[12:57] that work and that's it but there are a
[12:59] couple of problems with this and the
[13:02] main problem I would like to focus on it
[13:04] the fact that we have mixed the domain
[13:06] part with infrastructure part where is
[13:09] the domain well the pwetty reader give
[13:12] me some poetry this is just domain part
[13:16] then the file get contents and
[13:19] converting the encoding and all of that
[13:20] this is infrastructure details I can
[13:23] probably not ask my project manager to
[13:26] read that code and understand what it
[13:28] means however the rest if there is no
[13:32] poem the poem then should be the default
[13:34] one and return the poem this is again my
[13:38] business logic that my project manager
[13:41] can understand and read the code the
[13:46] problem of mixing both together is that
[13:49] first of all it makes the hard for you
[13:52] to see what is the business logic in the
[13:54] middle of all the infrastructure details
[13:57] you can imagine some queries to
[14:00] databases and queries to HTTP services
[14:03] right in the middle of there is some
[14:05] business logic here and because of that
[14:09] it's hard to test the business logic
[14:11] like I don't have the time to test this
[14:15] but if I were to test that I will either
[14:17] need to have an actual
[14:19] set up that like provide me a text file
[14:23] with the poem and one without the poem
[14:25] so I can test the behavior of my
[14:27] application in both cases and then I
[14:29] will need to figure out how to listen to
[14:31] the output of the CLI or I would mock
[14:35] the low-level details like file get
[14:38] contents so I can control what happens
[14:40] here but that will be terrible and I
[14:44] will need to rewrite that test every
[14:46] time I need to change how I retrieve the
[14:48] poem so usually it's hard to test the
[14:51] business because of that so it's hard to
[14:53] test the code so people don't test the
[14:55] code or not all of the business
[14:58] requirements and when you don't test the
[15:00] business requirements when you do change
[15:02] the code for any reason then it's very
[15:06] likely your code will break which is a
[15:08] problem also something I want to mention
[15:14] some people think that this will be a
[15:18] very valid refactoring you know to make
[15:21] that code bit easier to read I will just
[15:24] extract the infrastructure part in a
[15:27] function like read encoding file take
[15:30] file name and return me the poem the
[15:42] path where something like that okay so
[15:47] yes
[15:47] that's a valid refactoring extracting a
[15:50] function but that doesn't change
[15:51] anything to the fact that your domain
[15:54] still depend on the on the file system
[15:56] here so better readability but in terms
[16:00] of testing you still have the same
[16:02] problem so this is not what I'm talking
[16:04] about let's see how to solve that and
[16:09] let's discover what is exactly null
[16:11] architecture to me exactly an
[16:14] architecture it's the simplest way you
[16:17] could have to do exactly that to
[16:19] separate the domain part from the
[16:21] infrastructure it's a simplest way how
[16:24] simple that simple like you can how they
[16:28] do is more simple than two potatoes on
[16:31] the screen
[16:32] this is a simplest architecture I know
[16:35] and I just didn't draw two potatoes on
[16:40] the screen randomly I put the domain
[16:41] part at the heart of my acute
[16:43] architecture and that's because there is
[16:46] one rule which is the dependency rule
[16:49] and that rule says that the everything
[16:53] that is outside depends on the inside
[16:55] but the inside cannot depend on the
[16:58] outside and this is critical that means
[17:01] your domain should not know about the
[17:04] infrastructure part so where is the
[17:09] exact on here it is and this is
[17:12] something you should know about the
[17:13] exact on there is nothing about the
[17:15] exact on like exact on all is a
[17:19] marketing word because as I said Coburn
[17:23] so we coined the term exactly
[17:25] architecture originally named it ports
[17:28] and adapters architecture and that will
[17:30] make sense but is also a consultant I
[17:33] was a consultant when you are a
[17:36] consultant you need your IDs to stick in
[17:39] people mind so geometrical shape it's
[17:42] easier to remember like it's really
[17:44] marketing thing and that's a true story
[17:48] because he told us that it's an exact on
[17:51] because you know it's very easy to draw
[17:53] it's very symmetrical compared to like a
[17:55] pentagon it has not too few sides not
[17:58] too many so it's very convenient and
[18:00] that's it so this is something you
[18:03] should know about the executive
[18:03] architecture exactly know is marketing
[18:06] but the core which is inside we will see
[18:10] in a moment so let's focus on the exec
[18:13] on how do you make the domain not depend
[18:17] on the infra but at some point I need to
[18:20] go and read that file on the file system
[18:23] if you're doing object-oriented
[18:25] programming which I guess you are doing
[18:27] if you are using PHP you should know
[18:30] that we have solved that problem long
[18:32] time ago using something we call
[18:34] interfaces so this is an abstraction
[18:38] this is your intention and this is your
[18:41] business intention because yes I need to
[18:45] get my poem from
[18:46] poetry library whatever this poetry
[18:48] library is so my code my business code
[18:52] will depend on that intention and then
[18:56] somewhere in the infrastructure layer I
[19:00] will have an implementation and adapter
[19:03] that is saying okay I will get you to
[19:06] your poem an approach library and that
[19:09] will be using the file system and when I
[19:12] do that I switch the dependency I invert
[19:17] the dependency between the
[19:19] infrastructure and the domain you take
[19:23] the interface you call that a port and
[19:25] there you have the ports and adapters
[19:27] architecture and there this is
[19:29] everything that is about this
[19:31] architecture you put ports inside your
[19:34] domain and then you build different
[19:36] adapters on the infrastructure side
[19:39] super important inside your domain it's
[19:43] not just any kind of interface
[19:45] abstraction like it won't be an HTTP
[19:47] interface it's a business oriented
[19:51] interface again your intention pay
[19:55] attention to the business language try
[19:57] to foster that business language inside
[20:01] your domain and that will be better for
[20:03] everyone we have two sites for the
[20:09] adapter that's just a convenient way to
[20:11] distinct the two kind of adapters that
[20:14] we can have the first side is on the
[20:16] left and it's everything that is
[20:19] exposing your application to the outside
[20:21] world so that could be for example a UI
[20:24] or a CLI which was my case here or it
[20:28] could be a REST API and that also means
[20:32] that I could plug another way to consume
[20:36] my application without changing anything
[20:38] about the application and by the way
[20:42] tests are just another consumer of your
[20:45] application in a sense so if you're
[20:47] building for production for a UI for
[20:51] example you at least have two kind of
[20:53] consumer one being the test on the right
[20:58] side you have everything that is needed
[21:00] by the domain to do it stuff so typical
[21:04] things are occurring things from a
[21:06] database or from external web services
[21:10] let's go back on our example and and try
[21:13] to do that but applying exact normal
[21:15] architecture for real so I will start
[21:19] with the domain because I can start
[21:22] coding the domain with the business
[21:23] requirements that I don't care how the
[21:25] thing is implementing exactly this is
[21:28] like pure logic so we'll start with the
[21:30] domain part in the domain I will well
[21:34] create my poetry read your class again I
[21:37] will keep my give me some poetry
[21:40] function because this were really nice
[21:42] and everyone understand that and then
[21:45] when I reach it the poem this is how the
[21:50] magic happen I will read the
[21:52] specification again and this is saying
[21:54] you should get a poem from a poetry
[21:57] library and if it doesn't say that go
[22:00] and talk with people try to understand
[22:01] what is the logic behind what are the
[22:03] words so I will just try to reflect that
[22:06] in the code I got some kind of virtual
[22:09] library here and this has a get a poem
[22:11] method I think in a decision here then
[22:15] the rest of the logic is the same if
[22:17] there is no poem I should default on
[22:19] Alistair Coburn poems and then I really
[22:24] return the poem okay I need to get that
[22:28] poetry library and that I will inject in
[22:32] the constructor I don't know exactly
[22:34] what is the poetry library
[22:37] implementation but someone will know and
[22:40] give it to me and implicitly we could
[22:47] make it explicit but there is this
[22:49] interface of the poetry library and it's
[22:55] kind of a contract like I don't care how
[22:57] is it implemented but what I do know is
[23:00] this thing needs to give me a get a poem
[23:04] method so you can build any kind of
[23:07] poetry library as long as it provides
[23:10] this contract for
[23:12] this contract okay so let's move on the
[23:18] infrastructure part everything is done
[23:20] on the business side and now we need to
[23:23] make things happen with the file system
[23:25] so on the infrastructure side I will
[23:31] build a file system adapter here my file
[23:34] system adapter will need to know about
[23:36] the domain because I will be
[23:38] implementing the interface and the
[23:40] interface is defined in the domain so
[23:43] that's how the infra depends on the
[23:45] domain part so I will do a file system
[23:47] virtual library that implements the
[23:50] poetry library interface and because it
[23:54] implements the poetry library interface
[23:55] I need to provide a get a poem public
[23:59] function so let's do that and what is
[24:03] the implementation of this it's the one
[24:06] I had before I don't like the technical
[24:09] solution still needs to happen but I
[24:12] will put that solution here and all of
[24:14] the concerns around encoding for example
[24:20] will be here and the business doesn't
[24:23] change because of that so utf-8 and is
[24:26] OAD i-59 okay and I returned that point
[24:33] okay so I have my domain part I have
[24:36] mine adapter now I need to make that
[24:39] thing connects together or it won't work
[24:43] at some point in your application you
[24:47] have the entry point of your application
[24:49] and when you do exactly architecture we
[24:54] use the three steps initialization it's
[24:56] always the same recipe so I'm giving it
[24:59] to you right now the first thing you do
[25:03] is you instantiate the right-side
[25:05] adapters the right-side adapters are the
[25:08] one who provide the domain with like
[25:10] capabilities so in that case the file
[25:13] system virtual library this is a
[25:15] lifestyle editor so I will instantiate
[25:18] that and if it was an HTTP boy to
[25:22] library tomorrow and I need to
[25:23] authenticate this is
[25:25] I will provide the configuration for
[25:26] authentication I won't go in and pass
[25:29] this information to my domain part it
[25:32] won't care then as long as I got my
[25:36] adapter I can instantiate my poetry
[25:38] reader and I will pass the filesystem
[25:40] poetry library in that case but you can
[25:43] imagine I pass any kind of other adapter
[25:46] at runtime and in the end I need to
[25:52] expose that so in this example I'm using
[25:56] a CLI so I will imagine that I define a
[25:58] CLI adapter enjoy infrastructure and I
[26:02] will pass to that adapter the domain so
[26:05] this adapter doesn't do the business
[26:08] logic it's the role of the exec on the
[26:10] domain part but it exposed that like to
[26:14] the tli for example and then when I'm
[26:17] here really I have everything so I will
[26:20] put the app logic and the app logic it
[26:23] will use the left-side adapters so in
[26:27] that case I can like echo some here is
[26:32] some poetry give it some space and then
[26:36] I will use my right side adapters to you
[26:38] know do stuff so ask for poetry for
[26:42] example or it could be anything this is
[26:44] like I'm using the right side adapters
[26:46] in my entry point to kickstart my
[26:49] application and export that to the
[26:51] outside world ok I need to go back
[26:54] implement that CLI adapter so remember
[27:01] the left side adapters are how we what
[27:05] we use to expose the application so I
[27:11] completely arbitrarily decided to name
[27:14] that CLI and this should have this will
[27:17] take the domain in the constructor it
[27:21] will be injected so it won't know how to
[27:23] actually do the logic so we'll just tour
[27:27] that and it will have a method that I
[27:31] call give ask some poetry and what does
[27:35] this method do well it will expose
[27:38] to the CLI the results of my eggs egg on
[27:41] so in that case I will just echo the
[27:45] result of it but really this is a point
[27:48] where I could for example take input
[27:50] from my user and provide that to the
[27:53] eggs a column to executor logic and
[27:54] return that so I have everything is in
[27:59] place that should work I will call that
[28:04] so 0 2 0 3 yes it works so see I've
[28:13] solved the same problem but I've used a
[28:16] different kind of architecture it's a
[28:18] bit more code but it's not more complex
[28:22] not that many much complex and I do have
[28:26] time to show you how I will test the
[28:29] domain part because now it's super easy
[28:30] to test the domain part and all of the
[28:32] business requirements I can test super
[28:34] easily so for that I will use PHP unit
[28:40] and I will test my part you read your
[28:43] class so I can test the happy path the
[28:48] default behavior which is it should give
[28:51] me some poetry from the library usually
[28:56] I recommend you write tests first
[28:58] in that case for the flow of the talk I
[29:01] write them after but it's good to start
[29:04] with them first because you start from
[29:06] what you wish you have also I structure
[29:10] my tests with a given one then structure
[29:14] arrange a third act also it's another
[29:17] name for that and I start with the then
[29:19] part because the then part it's the
[29:21] final outputs so here I'm asking to
[29:25] myself why do I wish this thing do well
[29:28] I wish this thing returned me a result
[29:32] that will equal to the poem I will
[29:35] define okay very generic but now I know
[29:39] that I need first of all the result of
[29:42] my call which is the when part when part
[29:47] is what are you testing exactly in that
[29:50] case I get the result
[29:52] a call to the give me some poetry so far
[29:56] I don't really have to think I just have
[29:58] to apply like the recipe okay now I have
[30:03] to think a bit where do I find the
[30:06] portraiture well I guess I need to
[30:08] instantiate it so I will imagine that
[30:10] everything is ready for it so I wouldn't
[30:12] sting my poetry reader and I know
[30:15] this thing takes a portrait library okay
[30:18] so now I need to provide it a poetry
[30:20] library and I told you that the portrait
[30:24] library can really is any thing that
[30:28] implements the interface so in that case
[30:31] I will provide a mock and that mark
[30:34] won't change it won't change for
[30:40] technical reasons if that mock changes
[30:43] that means my business is evolving my
[30:45] intention is changing so that mock is
[30:48] fine I am controlling the context so I
[30:53] can test the logic of my poetry reader
[30:56] and in that case I will control the get
[30:59] appoint method and in that case I will
[31:02] return the poem that I no need to define
[31:05] so we'll give it another poem I stored
[31:09] from Misawa cheeky alright so here is my
[31:15] test simple to read I don't care about
[31:18] the file system or anything let's try
[31:21] that so I've got some PHP in it here
[31:26] [Music]
[31:30] yeah let's quickly do the next test so
[31:36] how would that test that it returned me
[31:39] the default poem if there is no poem
[31:43] well the beginning is the same I start
[31:47] with the then part it should equals that
[31:51] poem of from Alastair Coburn from my
[31:55] results what is the result
[31:57] it's the same call it's usually the case
[32:00] like your when part is always the same
[32:03] between your tests
[32:05] so I need the poetry reader again so I
[32:11] really it will be the same thing that
[32:14] takes a poetry library and the poetry
[32:17] library again it's the same thing it's
[32:19] still a mock of my interface and the one
[32:27] thing that changes here is that this
[32:30] mock it will return nothing so this is
[32:36] how easy it is to test the different use
[32:39] cases and I can run that again and it
[32:44] works no when the tests work for the
[32:48] first time always be suspicious so I'm
[32:51] just gonna make it say something oops
[32:58] okay
[33:00] it feels so it works and that's it
[33:06] that's how you do exactly no
[33:10] architecture that's everything you need
[33:13] to know and when you know that you know
[33:16] all of the basics but I realize that
[33:19] most of the time because it's so complex
[33:21] Lee told people don't really understand
[33:24] that basics and don't apply that basics
[33:26] so let me finish on the prose and also
[33:29] the limitation of it the first thing I
[33:32] want to say there is nothing new in
[33:34] everything that I said if you're doing
[33:38] object-oriented programming programming
[33:40] to an interface and all of the solid
[33:42] principle most of them are about
[33:43] interfaces really they're compatible
[33:47] with that there are about that if you
[33:49] follow that if you're doing functional
[33:52] programming instead it's not that
[33:54] different in functional programming you
[33:57] easily the side effects of your system
[33:59] with the i/o monad and you put that at
[34:02] the edge of your system because at some
[34:04] point you need to talk to the file
[34:06] system or to the database so it works
[34:08] this is why you are getting paid for but
[34:12] you don't want that to be spread
[34:14] everywhere in your application so you do
[34:16] like a functional pure
[34:17] core and then an imperative shell also
[34:20] called the onion architecture and this
[34:22] is the same domain infrastructure maybe
[34:26] the difference will be on what language
[34:28] do you use inside your functional core
[34:31] is this just mathematical functional
[34:34] monads and things like that or do you
[34:36] want to express the business language
[34:38] instead it's up to you the good thing
[34:42] about that as you might understand you
[34:44] can plug any kind of adapter to the
[34:46] domain it's a plug-and-play architecture
[34:48] if tomorrow I need to switch from the
[34:51] FTP to the HTTP it's not more complex
[34:54] because we're two month in my adapter is
[34:57] like 50 lines long what I need to do is
[35:00] just to provide another implementation
[35:02] of the few methods using another
[35:05] protocol and this is a short thing to do
[35:10] that means you can defer technical
[35:14] decision and this is what in my opinion
[35:16] a great architect can do it's not like
[35:19] when you're a good architect you have a
[35:23] lot of experience with different kind of
[35:25] databases so you're able to answer the
[35:27] question what kind of database do we
[35:28] need to use you are the senior developer
[35:31] so you might you should know that my
[35:33] preferred answer is we don't care for
[35:37] the moment like I will give you the best
[35:40] educated guess with the information we
[35:42] have now but really until we are in
[35:44] production do we really know exactly so
[35:46] do we need to go for the fancy complex
[35:49] stuff right now or can we ship fast with
[35:52] a simple solution that works today that
[35:55] is reasonable and if we need to change
[35:58] tomorrow we will be able to do that
[35:59] without it being too complex because if
[36:03] I can make the change in one month and
[36:05] it's still as easy to do the change it's
[36:08] fine it's not fine when you know that
[36:12] you're committing to a technology and if
[36:15] you're committing to it in six months it
[36:16] would be hard for you to change the
[36:18] technology it's only the first step
[36:22] though and this is a limitation I was
[36:24] able to do that in 35 minutes
[36:26] that means you will have a lot of
[36:28] question when you apply that in actual
[36:30] production code the usual question is
[36:33] where do I put the files well it doesn't
[36:36] tell you anything about that and I will
[36:38] tell you it's up to you it depends on
[36:41] the majority of your team on how you're
[36:43] comfortable can you make the framework
[36:46] just live in the infrastructure part it
[36:49] will be ideal some people start with
[36:52] like a folder domain a folder
[36:54] infrastructure and split like that I
[36:56] tend to prefer using something we call
[36:58] the screaming architecture which is I
[37:02] put the business in my folder names so
[37:07] when I'm looking at the architecture of
[37:08] my application oh there is search and
[37:11] check out one way roundtrip you're in
[37:13] the transportation business it's not
[37:15] just any model-view-controller kind of
[37:18] folder technical one and I don't know
[37:21] what you're doing exactly but really
[37:23] it's up to you I will recommend you to
[37:28] go start with that and then go further
[37:31] with the clean architecture it just
[37:34] gives you more layers so it answers the
[37:36] detailed question like okay this thing
[37:39] is more to the outside world and this
[37:41] thing is more like it's it's closer to
[37:44] the business but not exactly where do I
[37:46] put that this thing gather the existing
[37:50] knowledge about the different kind of
[37:52] architecture and gives you more layer
[37:54] but the rule is still the same
[37:55] dependency rule from the outside to the
[37:58] inside so start with extracting the
[38:02] domain part and make that not depend on
[38:04] the infrastructure this is the first
[38:05] step you need to do and finally if you
[38:09] want to build a strong domain like this
[38:12] domain part you will have a lot of
[38:15] classes inside and more and more
[38:16] business logic and to make that grow if
[38:19] you're not building a prototype if
[38:21] you're not in a hackathon if you're
[38:23] building something you're making money
[38:25] with and you aim to maintain for more
[38:27] than one year I strongly recommend you
[38:30] to bring your team to get into domain
[38:33] driven design not really much for the
[38:35] technical patterns that are interesting
[38:38] but they're not the most interesting
[38:39] thing
[38:40] but about the importance of the language
[38:42] and the concept that you can have
[38:44] different models you you don't have to
[38:47] have one big departure model to
[38:50] represent everything in your application
[38:52] but you have contexts that's it
[38:57] please remember Monday at work start
[39:00] thinking about domain infrastructure and
[39:03] how you could separate them both thank
[39:07] you very much
[39:08] [Applause]
[39:14] yeah we have I saved two three minutes
[39:17] for the questions if you have some
[39:19] please go ahead
[39:34] hi thank you for a speech it was really
[39:38] great but I have question it really
[39:40] seems to be a domain-driven design but
[39:43] you forgot to talk about application
[39:45] layer and you kind of mix it together
[39:48] with infrastructure would you like to
[39:51] know why and I have second question more
[39:54] practical from my practice so should all
[40:01] exceptions be converted to domain
[40:11] you
[40:28] clean architecture or other kind of
[40:31] architecture that introduces that player
[40:32] I told you you need more layers in the
[40:35] infrastructure and the application layer
[40:36] in is in the middle it's more the
[40:39] infrastructure side really going to
[40:41] clean architecture you will you have
[40:44] more information about that and
[40:46] regarding the so I have an exception
[40:49] should should I convert that into the
[40:51] domain exceptions all the exception
[40:53] including the infrastructure one no it
[40:56] depends if it's a purely in frustration
[41:01] it's a technical exceptions so it's fine
[41:03] to have a mix of both in your
[41:05] application how you do that might be
[41:07] interesting to discuss but we don't have
[41:09] time I will stay outside if you want to
[41:14] dig into more details of that kind of
[41:16] question but yes you can have both kind
[41:19] of exceptions in your application
[41:20] overall final question I know there is
[41:29] lunch all right thank you very much
[41:44] you