Merken

Get started with Component-based Rails applications!

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and and and and B and we always start why you here note I'm I'm I'm actually really interested in what brings you to this workshop like does anyone here have an apple as they the code base of a couple our research testing of a couple hours from the thousands of lines of code and they're like this this anyone this couple has OK this sucks I want to change something called is anyone here writing a lot of real that someone you know doing consulting it's been really off and what's the people so I hope so when I had a 3 hour proposal the 2nd half was going to be that really large code bases that we try to tear apart and in fact you don't need 90 minutes to terror lot of this was like months but it would be condensed and so this 1 is the this part of anatomy doing is only um Canada factoring out of the sample and support of but I hope that you will see that the and the ideas will apply in larger context begin with when read something about architecture you make these examples that make it look totally POV because you're doing the Subaru complicated things for almost nothing and that's gonna happen again today so bear with me um so are 1 Israel's applications ashtray what I and many different 1 and I work for pivotal labs and I'm in that category where I spent a lot of frills applications sound I have a feeling that I keep touching the microphone and funny when you're not I wrote a lot of applications but there was 1 time particular kind of kicked off where we were engaged with them for the from the 2 and a half years and after really really large and we're looking into ways at 2 to kind of bring some structure into it without you leaving the realm of the monolith if you will and so I did did that almost every at that time I did thereafter and and it's has still suggest is it's a weird thing to talk about because if Java conference I would give this talk if you were to go conference and we give this talk there's many languages in which this is so common that there would be no topic for me because that structure with applications to something that is a problem for Ruby because the way it is it's not a problem in other languages and and of kind become obsessed about if you if you kind of 1 just get an overview of the conference and find the talks on this topic that afternoon so but you know despite this not being talk um but a lab and I want to answer the question quickly of why you want to do component component-based I see a host of benefits when you add this 1 tool family component to your toolbox for us I'm going to go over these so the main change that you will see when you add components the application is that even be able to draw something like that graph and and that's have OK so let me just go the examples because it's hard to other was explained how important it is to have another structure like that communication so we don't know what this application is about but I can tell you that there's an importer that has something to do with programs as you can see at the bottom and obviously there's also something going on with sources and master so probably some sort of import and reconciliation of some sort of thing it's called program and 0 yeah look at the clusters so yeah probably that is the reconciliation peace where sources get kind of merged or whatever into masters if if I don't you indeed pick the worst part in this lab you should probably and so you can talk about your application at a higher level which you can't do because the of what what else do you have have module names but models don't kind of segregate so the important piece is not just that you have a box classes of boxes of fuel models of boxes but 1 of the boxes me and when you go to components you have arrows and you can draw them from 1 box to the other box but you cannot draw them back and that's the important bit so I can communicate much easier about an application because Avenue higher-level structure that we I didn't have access to before it makes collaboration is say I'm working you on source today stand up this morning we decided on feature that that such a source you have 1 that touches user in this graph again without knowing nothing else about the application we know a few things if I truly only change source I do not need to run the tests for master's programs reports users and styles my source code does not touch that source code that source code doesn't know that I'm touching something because you know that that exists it doesn't care about it suddenly to run those tests and similarly you have things you don't need to run tests for because you're not affecting that part of the code it's still 1 application mind you right but we don't need to test those things we only need to test boxes that either we change or that have arrows pointing into us because those little things that could be affected by our change and it also means that the area where we could potentially be in conflict with our change at the end of the day there's only 2 if you if you just go strictly by numbers and said all these boxes of the same size 2 out of and 10 boxes we could potentially have a conflict if you have 1 application no further structured you can't think about these things you can you can certainly don't have the benefits of running less tests and having less conflict possible creation super interesting when you say you have a larger new feature that you wanna roll out you can put it into a component and switch the component development and test and then review but you never switch on and staging until you're ready you can talk about you can change it you can show users you can maybe give be users access and the way you turn it on and off is 1 line of code where you turn that jam on or off the air in the respective environment In spite but say say reports is an API safe of I don't know maybe it's SOAP API we wrote that we don't like it anymore we wanna adjacent API the way you can create the JASigning EPI is you take reports the folder is component there you duplicated you call reports to your name every occurrence of reports with reports to and you start changing reports to whatever you want you can slowly work you way to reports to deprecating reports and when you're done you just turn on reports to you turn off reports and you codebases as clean as it was before when there is 1 major thing that a kind of underlies all of these benefits and that's comprehension because you can suddenly do something again you can do when you just have classes and and these are the concepts as your um is your mechanisms and that is you can do this when you onboarding someone when you're thinking about what you're doing you can treat everything that is below you as external and everything that's above you as not mattering at this moment so whenever you look at a part of code you have a much lower cognitive overhead to kind understanding what's going on because it's all smaller and you creating more and separation right so reinstalled now using their sweet test passed cool right so what's the act of England started
it i is a tiny amount is scaffold deprecated I don't know but you scaffolding to create these teams pages here the Falcons braves I have on my they also play each other which is funny but also the Falcons with which I don't understand because the braves have clubs but OK so the Falcons win in this case and this is his main contribution of the app so this is all scaffolds you know use right you everything with so but then you can ask the and if the Falcons play the braves who's gonna win so we have only 1 game Falcons 1 came prediction engine parts Marx's thought that when again so so this is what the app does the
structure of the application and now joining mean opening some code the structure of the application is interesting by the opened the source code the 1st thing you notice is what the he knows is composed but there's no AP directory so you can but you don't have to you can delete the application you because you can replicate it inside of the component and so amusing component when I talk about gems and engines inside of an application their vendors with the code I just use all of those things and that often mix amount of and yes there is a component of all right but when you when we try to understand what's going on here probably easiest thing is to look at Rowson realized there is indeed nothing in this application that provides anything it's just kind of gluing and that an engine into this so the see what's going on we could look but into the rats of the components and that looks more normal right Ignacio games in teams and prediction but but keep browsing around if you see something we're just shout it so it was gonna talk about how I think or how I view these things so the interesting bit in the gym file which obviously users act apposite component and this act needs to be loaded so we have a gym map here in line for and and it pulls it out of the past this passing is usually is documented as being for gems in development where you have a local a dependency on other jamming and developing that so you pointing to it locally and I guess that's kind of still true because I'm working on this absolute everything is under development if you will found but so this is how this application out and when you bundle
that it's going to show you everything especially you here that is slowing down from source and and and this is something that when other people talk about is often say and then you have to publish it and what I say is and then you do not publish it not ever unless something else happens way in the future but you don't publish it this is wonderful I still
have 1 application here and if you look into act effect this is tough totally normal except for this annoyance of seeing this namespace active but if we go through this there is nothing surprising here again yes and an engine so we use multiple engines as we'll see in a 2nd but uh so everything is is namespaced with the name of the engine games controller pretty normal predictions controller our teams a welcome page and and then game again namespace so yes if we find the migration also interesting made by the migration for this team obviously it's called apps actemes teams because also the migration the tables are namespace 2 components and but as you can see the migration lives inside the engine and you may have seen for what is it divides think has has a helper to install a couple tables um and in many engines that you download and sorry that you that you import as kind of external dependencies will have this rate task which is a rake engine name migrations install or something like that which which installs the applications into the main application now we didn't mention earlier that there's um that in indeed there is Donald migrations and there's a little trick you have to do to make this work um and that is I threw initializer in here which the migrations it it detects when it
gets loaded into Rails application and in that case it takes its own and migration so the apps migrations and adds them to the main apps migrations that way you don't have to copy them and and they just get run that's why when we run a breach do so you
Solomon haphazard doesn't have migrations but when
migrations they're just there because that that kind of approximate see I was going to have a later slide that says that is the worst component ever come up with but I've already confused myself 3 times so AP is clearly the worst component you could ever come up with all have more of those later but
a OK let me check if of talk about all the
things other questions people are concerned about me during the summer lab folder gems loaded in the path so that we saw that is an engine was surmountable and mention that so the roots of migrations non-publishing the funky this is 1 thing you will but you will
find annoying and it is truly annoying when were poles in a jam it looks at the gym speck of that gender which is why it's important that you always list all the dependencies of that Jim and I would suggest you do both um runtime and development dependencies he listen fully in the gym space now you can uh and you can still give gems
Jim files that's used for local development right and so were locally developing and I happen to check out this TrueSkill which is the prediction of room this things using factor ranking of but so it's using a get version because that published version is broken as on maintain some using that's the wisest funky well when bungalows this jam it looks
at the gym spec and it says TrueSkill and it it is gonna to regions and download any merger to because in fact and in even a version and to prevent it from doing that I need to restate that line In the main at an effect it up the transitive dependency path and need to restate such an unpublished genomes it should have and that's is unfortunately I looked in the bunker I think it's not possible to to change that in an easy way where
we would kind of have not have that problem but use also so that that
in the regions that every other production dependency has an explicit version not not to tell the arrow the greater the reason for that is we don't want untested coding production and it could happen that if you just say you know rails till the and there'll for 1 nite that you actually get a higher version so you can run your tests potentially you can run your test in the gym with somebody in rails and if you're if your application states this this dependency slightly differently you could be running the application in production against different version rails that's like having untested code because you're testing it with some dependency knew running it with some other dependency so locked the dependence down ensuring that you force the apt to have this version of rails like that this
is a lot of and stuff and there's 1 more
thing I want to talk about so I created this test file you which counteracts the Auspex test that this engine has um and the reason for that is that I don't have to worry about changing my bill script the thing you ran at 1st when I add more components only easily able to refactor and this bold scriptures finds all the test status age files in the In that under this uh application and runs so as you notice there's a test stage right next to this which runs the test for the main and what you probably also notice when you ran
it is there a lot of tests in and in the
Indian act and there are very few tests In the main application the reason for that is I highly recommend that you run that you create your tests local to the code so that you can in fact think about those things as components in the independent way and so you have to think about what is the contribution of some component that it has needs to have tests for and there's only for tests in this main application because really the only thing it does in this the and so the
test and are in fact you could say as a little bit much because it's testing that all that this structure inside of act right teams games and predictions are not a feature of the application the feature of that component and and you can kind of go year old discuss that more but I this kind of test as high level that the glue code works that's the intent right test that the blue coat works if your job is to glue whatever you're implementing if that's your job right so that's all you need to know about components and so now we're gonna make
yeah but which 1 socially at I showed you a couple of the files you have in front of you please look through them what should we
extract 1st the the so right now looks like this but do you see anything and strengthen the structure that might be in this application thank you so the prediction engine yes thank you today to nature stratified so the prediction was 1 suggestion any other suggestions is there no other suggestions I couldn't quite see who that was why why the prediction all and it feels natural to extract I think that's yes it does to me too but if you dig why does it feel natural to extract prediction yes In the area of yes I I totally agree so games and teams are at tightly coupled in fact if we look at game if you open game you see that game has associations to the detainees the prediction engine is kind of a layer on top of that and if you look at prediction open the predictor the predictor has a gets things right that incidentally call teams and games but if you look at what he cares about the predictor doesn't care that teams of names no think cares about that is that teams of ideas and the only thing he cares about 4 games is that to i'd he's have a certain outcome in the thing that is called gains so it looks like that at least when you look at predictors it doesn't care at all about using names end so let's extract predict what I'm saying that that is let's try to extract predictor and prediction if you look at prediction that's kind of the the result I think in this of um of that prediction and so extracted the major if
you what the the Uncle Bob talk where he rants about having lost so many years in architecture where he says that we have this problem we bind our application to this we're delivery mechanism that happens to you uh http and uh this library that does that well which is rails if you think about this app yes it's tiny and I'll get up my soapbox it this app is tiny you can see that the
left side teasing games kind of across that set things up what we're really changing the world with the ruler of predictions here is this right side where you put into games and it tells gun when is gonna make you million years if this thing actually works right so that's contribution that's our domain so it feels natural it should feel natural and if we extracted and if I just them right about this what we discussed discussed namely it might not have that much to do with rails because it doesn't even care about teams and games being active record then maybe we can make this thing not know about rails and we can I all right so let's do that and by
that I mean you do that so the idea is we have 1 component already it's act would create a 2nd component it's gonna be predicted and even to this is defined by the way I have no idea if this works on so because we said this is likely not caring about rails do these 1st 2 lines so what they do is we train a agenda is straight up him not endangered and you'll see generates a couple files for you and I wanted to delete get because we are keeping it in this repository and we just want you know mother get to kind of take over and then there's just a few steps a b very gnarly steps that we have to do to extract predicted so it felt natural to think about predictions separately move the classes so predictor prediction move the test there's a thing only predictor test in there and now these things were namespaces act right we're taking it out of the AC component were putting it into a predictor component so we probably need to meet rename space everything that's in there and then it fixed tests then we have to obviously were made this agenda now so we have to make sure that it gets probably loaded in the component because AP depends on this thing and then hopefully we can fix the tests and the engine um and we can run it we can check that the main application still works the just so I'm not have to do something that most people are not interested in is anyone actually interested in doing this right now there is a hand OK so just go well what Roberts you have school and they're all will be really interesting if you have if you can't run your tests or if you find out what you need to do to make the tests but in predictor run a shot up our combined will discuss so what you should do is you should start by creating this gem and making sure you can run tests and then you move the files in it'll blow up all over the place keep running the tests and fix the 1st thing that that breaks these things and keep going and as soon as you have the test inside of this new component of working go 1 step out what's 1 step up from this 1 will the AC component depends on the predictor components component so the next step out is run the tests of the AP component and only when you've done that can run the tests for the main at of rails engine new mountable is that off-limits we were for this 1 yes just up to create a straight up there so by the test running for anyone and if so what they do for the kind of someone had a bottle installer from PG where those will produce very going in going to the component that you just created so go into predictor of and that all of the the method the this app does not depend on PG some kind of concerned that you seem to have you can see Figure I where was it it In the production Jim fathers POS press if you have trouble with post press delete that Gates anyone else having different problem and pose press yes as all of that and if you at least for me if I do bumbledom predictor it'll create an ice pick on how 0 OK Oh yes I guess it says the answer the questions I did that again this morning and it didn't ask me questions I would take our stick because the rest of the app is tested with our stick yes all of which folded lower predicted going that's a great question so these things are gems and the only thing we care about is that we can load these components right and I you saw the path command you sort of have option on this understand it doesn't matter if you put it wherever you want you just change that have to be correct and everything else is gonna work I already created that components folder so the next command might be for you to move predictor into the components fold it will also have benefits and when we do the next 1 is anyone at least kind of getting it are spec test output is on getting readers everyone so blowing up the going that and yet again so if you've created that if you've created the gem you can actually run our spec right away which is great because tell you that it's passing because you have a sample test and I think that is like expect to be true so now if you're in that state take the to take the predicted the prediction put them into the predicted that GM move its test into and try to run that basketball yes prediction the door the the the the the when you copy the predictor spec and you created the bundle correctly it will ask you probably to override existing spect files so then you get rid of that sample testing should see braking tests is from which we want to make it into so I don't know which the and so you into so you know tests in here so take the take whatever energy use and take the predictor test out of that component and moving in here and take the files predicted prediction hardly we have components here and then run the testing that yes here's some males lost so this is working operate so those 2 4 2 1 again go by the standards together kid going to goodness that's a the lungs and so you're packing away and yes you realizing wall it's kind of knowledge so let me flail in front of you and by the way I always use
remind and things figures
by so I set were removed get from predictor if you're still going strong you feeling you get in there please keep going I'm just going to try to do the same are we taking the predictor a movie into components if I look at my application In remind have predictor here the predicted
doesn't do anything right it's an empty and but it's it was nice enough again the sorry different version of this bundle so it asks you question for some reason it didn't ask me a question um so we want to take extract just the prediction so look for model here's a predictor spec from moving out into the spec here just overriding what was there and the models and taking prediction predictor out and moving them into the namespace predictor inside of the gym OK is that clear start meaning that you realize you just start talking and so if we now go into this genome and run
specs it's blowing up there I'm getting is uninitialized constant act and that
makes a lot of sense because we just took something out of ApEn moved into that model predictor which is what the gym has an obviously that doesn't exist in this particular error comes out of the predictor spec if you wanna do this testimony just fix this 1 thing here the and run the test again is going
to fail some different lines it does not predict a predictor if you don't do this test-driven you can
kind of just start searching for AP and
replace it with predictor so when you do that here so a test I look OK right there is 1 caveat perhaps that's garbage now there's many carriers 1 particular 1 right now is that a the predictor being the class name is also the module name which confuses Ruby so in this particular case and and there's 1 more you should use the call uncle 1 in front of predictors are is good prediction this is what's going wrong or in fact if you're on the test right now as quantum
wrong somewhere else it doesn't know predictor why that James known model stuff and so
we have to actually require those 2 files and so I like to put my local requires here
I would reporter relative predict the set of prediction predicted from the tests now are still same problem because well this is still
running space fixing the namespace in these
2 files the this wrong in the red this
did anyone so far get to this stage I have no idea how complicated this is if you have never done but they did these steps to make sense to any to go over 1 of them again but there are a few truck I mean that it can try catch up the thing had in yes the I think that and think because we don't have to make in multiple injured thank you versus a wise about amount to land in my eyes adjust to jam the question should be the other way round y Stefan have you been so nice to me that you didn't give me all the crap that is connected to an engine why can I live in this wonderful world that is only Egypt because only I screw up my world images so many dependencies come with an engine don't add it if you don't have to we we had this discussion earlier that the predictive feels like it doesn't need to know what rails it seems to care only about a few things about these things called teams and things of games so we're just trying right now the to make this thing just the genome and not include everything rails if you have a lot of gyms components in it happened that don't depend on rails do not easy to stop they rails none of your app cares about rails is really easy to update there were 2 questions the yes hello great questions are we moving every yes I removing everything of predictions into this new components when he when the con was made over here that the prediction engine feels like it is a separate part I should that I consider that to be the prediction of the thing that makes the prediction that drives the prediction so what I want you to extract and what I just did extract were only predictor and prediction not prediction control or not use will get their leader and also if you get lost at any point and look at the gate and history of this project to find a branch called workshop it has 10 steps we're trying to do step 1 and if you just 1 can see what it will look like check that out lower or gone over the rest on yes Oregon clarify that but book I wanna do that later so this is only half as is at the core of this application is to predict the outcome of a game the delivery mechanism in Uncle Bob's words is that it is has a control on the see so let's separate those 2 1st can the intent of this 1st a yeah and this yes i are we expected to put are spec into the dependencies in this component yes making a development dependencies in that Jim Specht which will make sure that you have when you try to build just the tests of that component that you'll be able to to exercise which is why and also so again in in in a gem you don't get the rails autoloading a
new sensory 1 9 something you can use well of require relative so you know those 2 files to get access to prediction prediction but OK
er is early someone making more headway now yes the so you think I could cost that's another civil so you can see that the folder structure between the engine and a gem is not quite the same
engines are the core of every Rails application and they tend to its automatic support that you put stuff into act I and in the module under a gene's on the other hand our library so they historically put all their code into linear now you can make the reverse work with either 1 but yes the easiest thing is to take it out of AP models now prediction predictor and put it into labor predictor in the genome yeah right so
with with these moves that I did so I you know I have had the slide up earlier I moved the 2 classes and moved the tests I made sure respect was there I ran the tests I changed a couple of module names from to predicted do what by the way people will say that I'm doing job mobility this kind of stuff and then you could answer yes and others to be easy because with static typing it's much easier to rename all these models and so that's what we have to search and replace and don't have those those niceties but we have a different problem right now here up on the screen so just these remains led to the problem that we don't have access to this screen team the and this is something in the test if you if you find the source
to that thing I'm not a huge fan of a factory girl in those other object mother libraries I find such easy pattern that I can always write write it myself so create team is a short method that saves a team that we've nude up but as you can see here so the 1st up the gendered and find this method so we could add it and then we would have the problem that you see in line 6 because that's actually creating an app and I was saying earlier when you could create components you have arrows and a point in 1 direction but they don't point back and remember we're extracting the predictor app is gonna depend on its predictor will not have access to any of the things that are in that it should but we also said that prediction doesn't really care about anything about about team game must look at what exactly cares about predictor um predicted cares about so you give it to when it
initializes so futures how learned track you
initialise you a bunch of teams that's kind of a set up as a look up you can see here commits a hash effects practical and so it cares about the team ID that's how it does the lookup um and then it stores the team in line 6 but we don't offer does anything with it and if you look at learn it takes the form it takes games and cares about the ideas of those teams again so it cares about the ideas and then cares about the winning team this is lines of 70 here this stuff by cares about who wins I the many cares about the idea when it predicts and that's pretty much it then has an internal stuff but it doesn't care about these things being active record so I suggest that this um that we can change this test to be something like but to be
something like this as I said I think what the test cares about is that there is an IDE honesty so why don't I give it something is that that there when I get something has an ID is anyone fundamentally disagree with this cool 1 so there is of course more here is a new game some I do the same thing for the game and effectors couple more down here let me throw that in there from the test again and um and then going to the spec helper and
require a structure OK there are changed once again because I can't spell so
and into your question right if you can do something like this where you now got rid of the entire dependency that is active record and you never have to worry about its instantiating a database again predicted doesn't have a database you don't need to run migrations nothing gets stored in these tests are going to be really really fast just from this 1 change the so you could argue I asked about if someone finally disagrees with this because you could argue but now you're just assuming that 0 construct this thing is the same as a game or a team and that's not really that's not really safe what we have test around it right activists what it's doing with these teams in game so that's 1 argument for it if you're really uncomfortable with that look up of bounded context objects or we could do instead of this is we could create a prediction gain class in the prediction team class that get nude up with something that has an ID and with something that can kind of show if you win or lose and use these 2 things and new those 2 things up in the test and in the actual change its usage of this predictor to create these bounded context objects and passes them in 2 when it uses the predictor so that's an alternative you can use if you like to see more classes the air we now have is that we actually had attenzione app that we currently didn't give predicted and that was the actual prediction engine the external 1 that we currently use so there is also this this nasty thing here
so as I said we can remove this this dependency life from from AP and because it is it is not published yet so I'm going to throw this into the gym file where's said earlier we also need to have this in the gym spec this looks really nasty but
there are no runtime dependencies in this gem but now there are mainly these 2 scales this on the test again nothing changes gems don't
all rotate we need to add this to TrueSkill things in fact we can probably also remove it from that which should be loaning it in
its give so if you've never worked with Jens all of this is really really weird if you've done gems this is all this normal kind of GM behavior we just refactoring all of the faster over these gem seconds they can remove the require from AP because AP in fact can also remove its dependency on on trueskill trueskill is not implementation detail to the predictor engine right we can yes the others will depend on it transitively but they won't know about it directly on and once I add require appeared
I have some apps somewhere lossless you without is 128 in predictor there's perhaps
self act prediction obviously wrong this is that moment where these 2 columns here at the front part needed because of meaning the model predictor in the classes the the has anyone that these
green now this yeah you about
to but put the required for what all predictor the required for the um the external prediction engine I put into the libraries I don't know what you call this file actually this is kind of the file that you
require that gets required 1st when you require this gender as the required unlike requires cannons splattered out all across a file separate them they up front everything OK any questions up to this point we we basically just extracted a gem yes this year yeah predictor just think a lot of the Oh thank you this is not gonna work you here it's funny because we've bundle so I'm yes that
was you know my desk they didn't then compiled 1st run whatever but the
test pass because we didn't bundle again had we bundle they would have blown up now that we're bundling
recalling the dependencies and so 1 thing I suggest we don't to kind of clean things out if we take this test here and it's going to copy it because I'm
lazy we jump into the gym and now obsolete adapted because we're not gonna we're gonna maybe do solely that we nice but we don't wanna do anything database so final come back out to the main application and run build yeah when I say test outward
so we're going to be at component and when you test here and the and then pass because obviously we never renamed predicted in the outcome of so it's gonna
be in the controller we could test
physiologist find all places will quickly so in prediction controller were referring to
predicted that's no longer found because it is now predictor predictor but that's not the only thing is going on because we have a new
dependency is that and that is the predicted so we need to add to active component we need to add the predictor and we need to also make sure that the predicted that the AC component knows
that the predictor component is in the past and I was showing you earlier that you can do that with that path is and with path as an option there's a nicer way to do that which I suggest you use all the time which is uh do books so you can say past due and I give it the path where it will find components um Tennessee gem predictor and that's still is not enough because gemstone overload anything so I need to require the predictor In
the other component to see if I got it right and because
there's test that also using adpredictor so I have 1 test failing because it's still refers to act prediction but and it's right about
here the the the so we're moving art
we're working our way out right moving into the gym run the tests the past inside of the gym move 1 level out make
sure we require a nature we remain what needs to be renamed run the test again and if we did it right because this is a otherwise 8 factor the In
the tests on AP level or high-level level enough I think I can run the build and all of the
test suites and you see it just added the the test for the gem but it had a right there was yeah what happened here so this is where yes the all and you the test as age for the Jim Thorpe suffered the the new predictor gem I just copied it from happen removed everything that refer to migrations it is yeah it's the same test status age because we're just using our spectrally but you know sometimes it's helpful when you have all respect and you have maybe future test run slightly differently than you have Jasmina something that just from and so you have with multiple things are on this test stage but this is dangerous what happened here just now is that we install predictor to about 3 . 0 the um to approach and
so this might be due most problematic thing about doing component Israel's bonga is all set up to pull everything from regions so if you forget to tell the application that what you're looking at and what you want to use a local gym ended in do not pointing to it because remember I never went into the main applications Jim file and informed it about the
fact that we now also had predicted the so just went out to gems and it it's funny enough because his name is generic enough it found a
predictor and we've not pull that into our but in fact you would not find a single braking tests because they're actually you would you would there is a test breaking who happy with that so there is a
test breaking because that predictor happens to not define the class predictor predictor the because it doesn't do that the main at which I've said all on covering this glue code here when you look at abstract if you look at the abstract and the features of the main that it actually does tests a little bit more than the blue and this is the reason why add that because I knew was gonna miss it today so it's testing a little bit more to verify that we have the right kind predict so to fix this we can do this but it is certainly the path
block so it's much nicer to give it the block you can remove these paths the kind and we're going to unsolved predicted
and we can hopefully bundle and we see here it's takes apps from our components and here it takes predictor from our components and in fact as I said with the past you don't need to
specify transitive term dependencies so we can respond this and it will still pull predictor
from the right place how long is the session the 0 no 5 20 OK Freeman's cool and questions and the other thing try this 1 what
and I removed the predictor Jim from the main Jim file because the past due block is smart it knows to look for any transitive dependencies in the past so we can remove this because the main at doesn't depend on predictors the main at is a that we go back to my slides the main depends on on the AC and that depends on
predictive so you wouldn't specify right if if the rails it has an active record you don't specify Active Record you specify rails and the same thing with the do what is possible for components alright so path do not require the gyms and there's no kind no changes to the number to the production code I think this from here also I in the module at the only production change we have is that we need to refer to that predicted by open struck this little trick which works in this case might working years but I'm getting rid of dependencies and you don't need them is a great idea I right so I don't know the real for anyone feels this is not relevant for me at all I hope you will see it is and if you've got tests so you can refactor right if you've unit tests that's if you have a couple layers of tests you will be able to perform such refractory I've done code bases that were hundreds of thousands of lines long and you just find a small component that you can tear apart and you just tear apart and when you've done it a couple times it will feel more natural seen teams that start having templates for their for their components because the kind of always the same so they can use a template and go off of that I we keep running the tests that you saw me doing this I did know was going to happen you'd keep running the test and ask the code what's wrong and you run an inside out because if you don't run them set out is going to get so much test problems they used the overwhelmed start with the gem go to it's to the things that depend on it so go in the reverse direction of the dependency tree recall up the dependency tree fruit tests and then where you can remove dependencies we didn't need rails for this prediction we shouldn't have so the predictor is now completely free of it if if if you don't if you want update and in fact we could extract predictor publish it to a gym server and use it in multiple applications and they would indeed not care about us but um it's also kind of this single responsibility principle on higher level right the least amount of reasons to change when we can achieve that all if we don't have rails there's a lot less reasons to change I so what else is in this application is a more structure in this application and then if if you feel you know this is all very academic or a very loudly yes because a small example but you can you even apply the same thing to larger and applications there is more structure in this application if you look at what is actually going on you see that the team controller doesn't need to know that games exist it cruds teams anyone disagreeing doesn't need other games exist because it doesn't know in this application it does because this blue box is currently the truth right it's not these little boxes in the game you Y needs to save our teams in a way because it's storing their relationship as it relates to gains the prediction EY in kind of needs both of them right because it needs to show you the teams it needs to access the games to make the prediction the predictor our is now can out of the given the time that it took to do these refactorings and we'll do the other ones just up here will check out code and take a look at so the Montreux is if it doesn't have to be connected if it doesn't have to be together it shouldn't be if you don't have to untangle it stolen template in fact that's my from my opinion is whenever you have a code that can touch each other but it will if there were a couple people who raised their hands and said I have very large rails that we'll look at your app you go into the lid folders have you ever checked whether you can delete the rails act and and really all the tested not pertinent to the live folder and run the tests for live folder do you think that's going to work it's not going to work the reason it's not working is because you live folders entangled with the application if you truly want to have a library you put it into some are component like this predictor and enforce that the test run their own even if you have no active record or whatever in their try you will have I don't know patch within different axes in there or something and suddenly you have a dependency on rails so what can be separate should be separate you also saw something of the interesting it's freakin painful to repeat the apart so if you can create something new and start immediately with a new component you have to go through this it's super easy to take 2 components and smashing together because all you do is search for that 1 namespace in the 1 and merge it all into 1 namespace it's really really easy trust me if you doing components it's super easy to do separately to compose right off the bat it's really hard to extract them like we just did which is also why it took so much longer but I said this was gonna work at this at the outset so but if we want to make these internal arrows there that kind of put in there if we want to make those happen we need to make every 1 of these things into a component and this is where truly believe the predictors a finer factor and I would probably do it in many applications these days the next ones I would probably not too because they're a little bit small would you could argue that there might be such a thing as a team Adnan the only thing they do is scrape the newspapers and admin teams actually want to give them a separate you I how cool would it be if this you were 1 application and it didn't know about all the other stuff serving as a moment so teams you and teams were separate and didn't have to know about the other stuff less resist the change so this depends you what if we could actually make this happen and we can so when we tried to do this and we push persistence down which is the 1st step so we take teams and games and move them out of the AC component the like so this is where we will have to use an so rails plug in New and and I realize that it takes too much time so
let me just check out a version of the code that has both teams and games extracted into components the way the back
in the day in the the history
it takes on do you yes right if you
check out the tag number 3 you should see me 4
components inside of components
so and if you look at games just take 1 of the 2 and look at them they're structurally very very similar are the only thing we have is a multiple because the only thing that these engines need are the models I said I want to extract the persistence down right this game is is otherwise unchanged that same stuff and there was a reference to the teams that class names here so that needed to
be changed to point to the teams are modeled in now again we we do have the migrations in this engine there's another cool side effect if you leave the migrations in the engines as I said earlier you can move them around so this this migration is is just uh the moved file that was earlier in the AP component is just moved over here to be able to do that you should adopt the rule of 1 migration per table because if you have multiple but Active Record models you're not sure where whether even in the potentially into different components you need a migration separate so that you don't have to go through a whole hassle of migrations back and forth to separate out the migrations you don't touch Neil migration you can't write member in production schools already running so you just add a 2nd migration that does the rename it would you know in fact if we look at a team is it has exactly the same thing and in its migrations that's so make 1 migration per table and this will always be possible no matter how complex your app gets I what changes with engines is that we get well the engine in it is isolated in space so that anything inside of things is in the model things other lines 5 2 5 2 9 are saying that we had earlier they will show up in every engine that adds migrations to the application I also had showed you before that I don't like to use f factor going I showed you my my hand rolled object creation when I extract teams and gains in fact power the controllers that are now a
different jam how are they gonna what teasing names if they needed for their for the text those are creation methods should live in those controllers because that's not their domain reducing this another gene's why not exposed a games test help so the games test helper as
an object creation method inside of games which only can create games for new and creating and if we look into AppInit specs In the spec helper here line 10 and 11 but 11 12 it
requires the test helpers from teams and games so it now that that in in affected the games German the team's gender were nice enough to provide their own test helpers something that is you know good libraries will always provide is something like that and so here we're doing it for ourselves so and see what else we need to talk about for these so the process is otherwise very similar to
Ukraine engine and these these means skip bundlers could get skip would be scared the use skip you skip sprockets skips get jobs students get tested escaping basically everything because this engine only cares about models and I believe if I if I the um if I
remember correctly this engine doesn't care about rails so I actually depend made dependent on Active Record because it doesn't need to support active all the other active things all the other adequate these units Only gets is active record and again as few dependencies is you can have and create on are there is a dummy up the gets created with engines that dummy out makes people say this is a really bad approach because the dummy up so large and that's true the dummy up is very large and gets all created there are people who try to avoid it there's a gym I
think that gets rid of this Tommy up you can see that this coming up is massive what is the good seats inspect on and the spec helper effect does not load the engine it loads the dummy apps rails which in turn has a requirement of the indeed it's just the way you test an engine for the tests you put it into a skeletal Rails apps so you can run tests against you can get rid of it I often don't do it because the dummy have never hurts you just ascus sits around and this is just obnoxiously big but that's really it's only problem an yeah I Our should you the the renames that we had to
do I talked about the test helpers and how they're used other exposed by the the engine and has the content in exposed to other parts of the application that need to use those parts and so if you have checked out tagged were 3 and then you have this structure but in fact so what's in the blue box is only obviously 1 thing that conceptually we're still thinking there's more there I so because it can
do this in practice but there's 2 ways to do this engine extractions again it's nicer if you start creating fresh best 2nd best thing decide whether this engine is going to be very different or very similar if it's very similar in instead of going through the motions of creating a new plug-in Shorty have a component it might be easier to just duplicate the component delete anything you don't need from the new component and the old component and start remaining in the new component it's sometimes just easier is basically kind of of the blueprint approach where you just kind of this is all the stuff I need anyways and don't massive migrations you to move them over and then you add new migration so that you can change the names as appropriate the test of approach I think is a really nice 1 and also had a show this I would have tripped up on trying to a factory from this name at the entire time so let me get on a soapbox again for a 2nd if you feel
like you need to name the engine based miscellaneous general live your company's name or anything like that just take everything Croft random don't care don't know or die and it's about as good sigh these are proper margins and give anything you extract into components the most specific name you can think of a good name 1 that will still that was started the conversation continue to factory once you're in the habit of doing this it's not that hard to refactor these things and then continue to talk about it I was once on a project that was 1 of the schools predator was ever on and it ended up with 40 components and it was continuously 1 pair we were I think for pairs and 1 pair was continuously working on just for factoring stuff and we still had 1 of the highest velocity is Everest is that it felt like 1 of the fastest projects I've ever been on because the reflectance good for the health of the codebase and were able to do dual of trade a lot of code despite where rather maybe because we did so many refactorings and kept these concepts clean and that the sections are as skipped over a couple app is a terrible component name it's time we get rid of it so if you check out and number 4 that this is the assignment for its renaming acts to where the what I know it doesn't it's not really good name may so well what the hell does that mean at least it captures however that this thing is concerned with the delivery mechanism like again this Uncle Bob think this is the URI as delivered by the web and it contains the controls and the views to do so if you check this out your seats were not calling it when you like and that actually makes a lot more sense you could stop right there but when I say would keep going in that we already found he knew I gave you an prediction you without looking at the code does anyone see a reason why we wouldn't be able to just kind of vertically split team UID my prediction you all out of when you and the yes and 2nd on here for which ones are so the question was a the pages that need to reference multiple multiple and what and which ones of so what is true about your comment is that the pages were looking at containing a
reference to teams top left games
center and predictions so these things are kind of connected i and how to do that it so the somehow tied
also there's something even more obvious they all share the same you why the the share the same application layout see that doesn't change if you look at the source code you cannot currently extract these things from each other because the
essentially because this file exists In the AP component and if you try to extract say games you life out of the web UI how would it get to the layout it could so before you can extract any of those you wise into separate ones you have to extract Leon styles this is a very
common place where people will start calling that
base styles or something like that
layouts just very generic don't do it try to be more specific I'm not much better in this case I called web-style if we check that out it's a really easy refactor web-style only contains the application layer a couple assets sucess John scripts
and that kind of stuff and doesn't contain tests um checked out fight that right we've
gone over the basics as a web style contains only assets and views so there's that image that lower that we've seen as application various applications users and here's Application HTML right so now we have an external component that if we split something off of act we can depend on because in fact have already depends on web standards self 0 sorry this is just I mean when you I so when you I depends on web style and the big change uh there is that in the controllers so any application controller for say please use the layout from the web style component right so so into going to web stallion there's there's only the engine code
that loads it there are the assets in the views and there are the dependencies the rails you Slim here and right very small engine
it's literally just fix it moving out the remaining all the folders that you moving from web UI to web style so so that everything inside of web style obviously needs style here here here and so forth and not would you like and the dependency graph that looks like this now that we have that
extraction and now we can take prediction you I and move it out of that uh sort web UI and it can depend on anything it needs because it doesn't depend on the controls and that so this was web style so we
have to remove everything but acids and layouts remove acids from obviously the web UI it's it's always the same pattern take whatever you need if you move it out where you duplicated and then you deleted in the old place and in this case uh no no tests to write what is important verifies if you get all the the loading right
because 1 thing that I just kind of show
for a 2nd obviously the application layout is now referring to the web style applications CSS but so in the spirit of group in all of this apart I
we can in fact do this and move
all of these to be separate because they
live next they can live next to each other because of that's what I want to show the trait that has happened for this check out is this
here so style uses these paths and that will only work in the main application in fact I don't even know that I ran the test this because that looks to me like it won't work we should check it out later and verify that this works so the problem is when you extract web-style it has this navigation section in the layout that suddenly is no longer in its dependency right
web-style contains the application
and this the the template but it doesn't contain it doesn't nobody knew I gain of prediction your existing so this these couple lines here they break the dependency path that they should all this really
depends is down and this thing makes assumptions about the world that it should let me jump to the very end um other refactorings How
did everything we could to tender factors I
so at the very end of these refactorings there is a very simple way to fix this and it's a
very important 1 to know about 4 components if you cannot depend on something how do you get information about this is that this is the final state of refactorings it turns
out when you expect these 3 things off there's actually 1 thing left in the 1st page ever get to which is just an empty page but you could split off to so I that here and you check out workshop branch you will find the new idea new which you and welcome you and all these other things and the problem of and how to glue together this navigation menu you solve with what is essentially depends injection
and so the web style has the application layout but it doesn't know what things
are on the part of the act and that need to be shown yeah so in the main application I just setconfig there here Main that indicates an av entry from everything that wants to show itself if you will in the net if you look in FIL looking here this just on the module it's a name and use the rout helper defined 1 path yeah and this is for this is teams and again to configure variable gets set in the main application in this case and Web styles um where does it make use of that right here right so web styles just goes over the
configuration and shows the links now let's cells here says rails that application that can fit so web web-style expects and will actually block if the mean application does not defined can feed could called main that and that's what why call dependency injection is because you configuring something over here and it's just expected done years it's not really injected but is expected so you should write a test around verifying that this works and so the way to test web-style now is to create an empty and Diane but make sure that this configuration variable gets to some things you can test in isolation that the navigation con struct at least works and when you pull it into the main Apeshit test that everything still pulls together correctly and I think the AP spect never really changed for this application so it's still navigate all those pieces so
throughout the entire process this test nature that the entire application worked as expected when you have done this the test suite looks a lot different from what a
normal test suite looks like it's going continuously is uh create migrations because
there's a ton of things that need to create migrations all these separate engines you know the dependency path now orbit dependency tree everyone that is above teams and games needs to run
migrations but they all just run a couple tests and those tests typically run pretty
fast incidentally when you run this test we don't Travis very nice
because you can do this you can tell Travis you can use the gym file option that you have Travis to pointed to every single Jim file of every single component that you have and it will just run all the test suites in parallel so this is a build of of this state that we're looking at right now this check out of workshop for this application with Travis right now it has a bill for every single 1 of these components and we can see that for some reason welcome you why that's hilarious we welcome your i doesn't have any tests that takes 5 and a half minutes but um this is because of this Travis problem with loading gems you have to do a retry and probably constructed so all the test suites themselves are very small and and now with the kind I change the this whole worshipable that because the actual refactoring takes too long but what in
your application are these parts I will talk
about that for so it any than I would like to share I have this for that right please go ahead but I'm just going to kind of make stuff up that I've seen time and time again if you have effect or certain someone over lunch today so he was looking at TV channels and content for what he will have is someone who can admin people so that those people can admin channels and maybe other people that can add particular shows and then there's lot logged out users who pinch is who can see this content super admins channel admins show admins and blog that uses those are perfect verticals the user interface which is the website called reviewing called will probably look totally different than those sections but those sections could also be separate from each other she can make verticals of similar to what we have here t new idea new I had tried it say this earlier what if there is a person in Internet just inputs all the teams they may never touched the games because that's way too complex for the so it's a separate you I so in your at these things will be larger they will in the indeed something like a channel or they will be accounts or attendance or whatever those realize you can split off vertically with components and then you'll find as as you try to do that just like we found here that you find common things like to use engage their used by by multiple of these verticals so in the 1st you gotta think about your application how can I split this thing up in the vertical pieces and then you realize you have something common in the need to slice it horizontally because you need to pull out what's common the In our case teams games and web style so that everything that gets vertically split can depend on that if it needs to and as you keep doing that you'll find it's really easy to slice and dice in those things like you will if you get into the groove you make more and more of these and and in the end you can create really large compone structure yes at a very point you could argue so the argument is why not leave the web stuff in the main and you could in fact do that you could create the layout that the engines use I believe in ways it should be possible you could create that in the main application the In the components then you have a weird situation where you don't actually see what the component is going to be you get rendered into once correctly gets rendered into the main applications we're saying much like the application glues together just the mount points of the sentence it could glued together the U. Weiser of those engine and that's a very good point you could say the layout belongs there and then what you would test on the main at layer is that this application layout in fact does pull together the components like we would like the bowling together and it if you you can affect run any of these engines you can to stop a real server the dummy rails up inside of an engine you can run and to see just that component in action you itself contains you can run it and that would look different than the mean AP because it didn't have access to it I think I don't have to try to get looks nicer but I think it just might is an idea yes but now you're adding 1 layer of complexity so that the his in his product they have extracted styles into a genome and they have a constant struggle to keep this keep at all the applications of you using the same styles and in keeping up to date obviously that's something I recommend not doing as for as long as you can because this is still 1 application but if someone finds is predicted terribly interesting I might you know in entertain the thought of of extracting NXT publishing it to Jim serve Web style I would probably never published anywhere now if you have multiple oscillation is the same things then you start having these conversations but you see why but even if it was kind of painful to try and do the 1st 4 factors it took me an on-stage nervous and typing at the wrong angle uh 15 minutes to extract a component and why is that possible that's only possible because you keep this coding 1 codebase you don't mess around and not grounds with publishing the Gem servers updating Jim versions of and and and pulling down gems and and and pulling down all these applications these applications and components from different repositories is 1 repository does it stays 1 application yes so he has made a has a very large application there that right and men and a couple of engines and those are also preposterous the so here's the I'm a consultant so here's a free 1 I take these repositories for every single engine engine if if they're not using multiple applications which these large engines typically on download them and put them into components folded delete their get folder committed to the main application add the path change nothing else just add a little bit of the test suites as we were doing and tomorrow you'll just be able to actually manipulate engines within 1 application sigma factor this thing from that and into the engine running this engine over here and you don't need to check out 5 things and when someone who comes onto the job after the 1st day like shoot me now because there's so much stuff you have to remember this the 1st and easiest thing to make it much more productive if you wanna split of application I think it's 1 of the things that we believe reals applications can be large because we do stuff like that's completely unnecessary to make to put these things into different repositories no highly recommended on pull them back together and be much easier and that's just the 1st thing you can do as soon as you then find stuff that you wanna a factor you have 1 codebase you've just seen how easy it is to extract a GMC extractor gem and it won't even affect deployment as something I did mention and deployment for an application like this to her Roekel exactly the same there's no change whatsoever because you have some genome someone Erogul completely transparently deals with this path command as you push not yes yes by the performance implications of this I using Ruby so good luck around not so the real that is it real that is an engine + essentially which assume the dummy now you have multiple and so you have a bunch more classes yes so you generate a couple more class the classes printed 5 classes that's the overhead your loading killing 5 extra classes on the flip side however we have a dependency graph like this so we can start playing around with it I'm trying to see if I you can find some samples if you don't look at that company names please I this is the largest groups the largest component graph fire created it was very very successful it looks terrible that's because you can see how complicated this application is which every real that tries to hide from you because the structure is present you just can't see you can talk about it now what you can do with this if you want to deploy your application to this server over here in fact I this is also this thing where you have with multiple admins what you start and talking lumpers what you can do with an application like this is deployed and and you can change your gym follow this to the gym for as like tons of gems and right you could but a little magic in a gym file and and deploy only or alone in 1 context only 1 of the admins and load on the other hand on the other server and load on the web yes it's a very easy way also to kind of get tailored applications if you need to scale 1 part of it just make something where the gym from only loads that part and scale it really big you don't you low the rest I think the performance implications are really small and then there's also another common should make in rico talk merit a blog posts couple months ago about about building that in so using that blunder and um environments to basically reduce the footprint so that you support this just through the gym and so I think you yes there is an overhead to this to any structure there's over because you need to create and maintain the structure the benefits from that structural outweigh I bet you in in most situations and the cost the and
the so I I'm writing a book about all this I keep running around for last couple
years believing that this is the way you should write reals applications and so I said I would write a book about this if you go to this and link it and publishing it as in progress you basically just hurt the refactoring so you just heard I hope to be using for the next chapter to show sample in in standard extractions and so a gym extraction of the domain and the extraction of the persistence layer and the extraction of God's separation of UI components and so if you're interested is a coupon where you get it for 50 % off it be great if you could support mean that because it's a it's a lot of work and a lot of people think and crazy students so I 1 page that kind collects most of the information that I know
about writing applications like this is this URL that and and that's it be it choose
and
Maschinenschreiben
Telekommunikation
Bit
Quader
Momentenproblem
Formale Sprache
Klasse <Mathematik>
Mathematisierung
Applet
Familie <Mathematik>
Versionsverwaltung
Zahlenbereich
Kartesische Koordinaten
Code
Übergang
Informationsmodellierung
Reelle Zahl
Minimum
Stichprobenumfang
Vererbungshierarchie
Zeitrichtung
Stützpunkt <Mathematik>
Zusammenhängender Graph
Softwareentwickler
Cluster <Rechnernetz>
Optimierung
Datenstruktur
Gleitendes Mittel
Gerade
Trennungsaxiom
Softwaretest
Kraftfahrzeugmechatroniker
Graph
Kategorie <Mathematik>
Pivot-Operation
Quellcode
Modul
Quick-Sort
Kollaboration <Informatik>
Flächeninhalt
Rechter Winkel
Mereologie
Computerarchitektur
Overhead <Kommunikationstechnik>
Programmierumgebung
Verkehrsinformation
Lesen <Datenverarbeitung>
Bit
App <Programm>
Kartesische Koordinaten
Code
Computeranimation
Homepage
Open Source
Komponente <Software>
Prognoseverfahren
Spieltheorie
Mixed Reality
Zusammenhängender Graph
Softwareentwickler
Datenstruktur
App <Programm>
Finite-Elemente-Methode
Spieltheorie
Prognostik
Quellcode
Elektronische Publikation
Mapping <Computergraphik>
Gruppenkeim
Rechter Winkel
Wurzel <Mathematik>
Mereologie
Cloud Computing
Normalvektor
Versionsverwaltung
Verzeichnisdienst
Message-Passing
Faserbündel
App <Programm>
Kartesische Koordinaten
Benutzerfreundlichkeit
Computeranimation
Task
PROM
Komponente <Software>
Open Source
Prognoseverfahren
Spieltheorie
Migration <Informatik>
Skript <Programm>
Modul
Soundverarbeitung
App <Programm>
Namensraum
Installation <Informatik>
Volumenvisualisierung
Spieltheorie
Bitrate
Gleitendes Mittel
Emulation
Gruppenkeim
Ruhmasse
Gamecontroller
Normalvektor
Cloud Computing
CMM <Software Engineering>
Tabelle <Informatik>
Faserbündel
App <Programm>
Gewichtete Summe
Kartesische Koordinaten
Computeranimation
Open Source
Komponente <Software>
Last
Wärmeausdehnung
Migration <Informatik>
Code
DoS-Attacke
Zusammenhängender Graph
Skript <Programm>
Wurzel <Mathematik>
Modul
Gammafunktion
App <Programm>
Installation <Informatik>
Kegelschnitt
Migration <Informatik>
CAM
Gruppenoperation
Rechenschieber
Einheit <Mathematik>
Cloud Computing
Gruppenoperation
Versionsverwaltung
Gewichtete Summe
Ranking
MPM
Raum-Zeit
Computeranimation
Komponente <Software>
Open Source
Prognoseverfahren
Softwareentwickler
Gerade
Gammafunktion
Soundverarbeitung
Raum-Zeit
Stellenring
Rechenzeit
Spieltheorie
Farbverwaltungssystem
Teilbarkeit
Dialekt
Polstelle
Gruppenkeim
Rechter Winkel
Geschlecht <Mathematik>
COM
Cloud Computing
Versionsverwaltung
Softwaretest
Subtraktion
Versionsverwaltung
Kartesische Koordinaten
Biprodukt
Migration <Informatik>
Dialekt
Code
Computeranimation
Komponente <Software>
Last
Code
Codierung
Zeitrichtung
Versionsverwaltung
Gammafunktion
Aggregatzustand
Softwaretest
Faserbündel
Elektronische Publikation
Synchronisierung
Hardy-Raum
Installation <Informatik>
Statisches RAM
Kartesische Koordinaten
Oval
Marketinginformationssystem
Migration <Informatik>
Elektronische Publikation
Computeranimation
PROM
Komponente <Software>
Last
Emulation
Rechter Winkel
Code
Skript <Programm>
Zusammenhängender Graph
Eins
Normalvektor
Resultante
Bit
Natürliche Zahl
App <Programm>
Kartesische Koordinaten
MPM
Code
Computeranimation
Übergang
Komponente <Software>
Prognoseverfahren
Spieltheorie
Prozess <Informatik>
Zusammenhängender Graph
Datenstruktur
Softwaretest
Assoziativgesetz
Systemaufruf
Spieltheorie
Eichtheorie
Elektronische Publikation
Gesetz <Physik>
Flächeninhalt
Datenstruktur
Rechter Winkel
Einheit <Mathematik>
Schnelltaste
Kraftfahrzeugmechatroniker
App <Programm>
Domain <Netzwerk>
Teilbarkeit
Spieltheorie
Prognostik
Kartesische Koordinaten
Schlussregel
Computeranimation
Datensatz
Domain-Name
Prognoseverfahren
Spieltheorie
Programmbibliothek
Computerarchitektur
Faserbündel
Subtraktion
App <Programm>
Klasse <Mathematik>
Kartesische Koordinaten
Raum-Zeit
Computeranimation
PROM
Last
Softwaretest
Prognoseverfahren
Stichprobenumfang
Zusammenhängender Graph
Installation <Informatik>
Figurierte Zahl
Gerade
Funktion <Mathematik>
Leck
Softwaretest
App <Programm>
Dokumentenserver
Güte der Anpassung
Prognostik
Spieltheorie
Objektklasse
Biprodukt
Elektronische Publikation
Quick-Sort
Konfiguration <Informatik>
Energiedichte
Verbandstheorie
Rechter Winkel
ATM
Gerade Zahl
Faserbündel
Aggregatzustand
Standardabweichung
Faserbündel
Spielkonsole
Versionsverwaltung
IRIS-T
Kartesische Koordinaten
Computeranimation
PROM
Repository <Informatik>
Last
Informationsmodellierung
Softwaretest
Prognoseverfahren
Euler-Diagramm
Zusammenhängender Graph
Gasdruck
Figurierte Zahl
Chi-Quadrat-Verteilung
Meta-Tag
Normalvektor
Modul
Namensraum
Elektronische Publikation
Spieltheorie
Prognostik
Objektklasse
Lemma <Logik>
Rechter Winkel
Einheit <Mathematik>
ATM
Hochvakuum
Faserbündel
Faserbündel
Spielkonsole
App <Programm>
Klasse <Mathematik>
Acht
Gewichtete Summe
Extrempunkt
Computeranimation
Wurm <Informatik>
Komponente <Software>
Informationsmodellierung
Prognoseverfahren
Hardware-in-the-loop
Primzahlzwillinge
Quantisierung <Physik>
Gerade
Modul
Softwaretest
Gruppe <Mathematik>
Freier Ladungsträger
Synchronisierung
Simulated annealing
Spieltheorie
Systemaufruf
Prognostik
Zeiger <Informatik>
Vorhersagbarkeit
Emulation
Einheit <Mathematik>
Rechter Winkel
Bildschirmsymbol
p-Block
Term
Fehlermeldung
Auftragssprache
Unrundheit
Kartesische Koordinaten
Raum-Zeit
Computeranimation
Bewegungsunschärfe
Prognoseverfahren
Spieltheorie
Code
Zusammenhängender Graph
Inklusion <Mathematik>
Softwareentwickler
Bildgebendes Verfahren
Modul
Softwaretest
Kraftfahrzeugmechatroniker
App <Programm>
Namensraum
Elektronische Publikation
Verzweigendes Programm
Spieltheorie
Übergang
Elektronische Publikation
Netzwerktopologie
Verknüpfungsglied
Emulation
Menge
Mereologie
Gamecontroller
Restklasse
Projektive Ebene
Wort <Informatik>
Speicherabzug
p-Block
Versionsverwaltung
Verkehrsinformation
Software Engineering
Kreisbewegung
Kartesische Koordinaten
Extrempunkt
Computeranimation
PROM
Metropolitan area network
Informationsmodellierung
Arbeit <Physik>
Prognoseverfahren
Reverse Engineering
Programmbibliothek
Datenstruktur
Gammafunktion
Modul
Elektronische Publikation
Prognostik
Spieltheorie
Übergang
Elektronische Publikation
Modul
Emulation
ATM
Restklasse
Speicherabzug
p-Block
Versionsverwaltung
Schwaches Gesetz der großen Zahlen
Punkt
Klasse <Mathematik>
Extrempunkt
Computeranimation
Richtung
Informationsmodellierung
Prognoseverfahren
Fächer <Mathematik>
Prozess <Informatik>
Spieltheorie
Mustersprache
Programmbibliothek
Zeitrichtung
Zusammenhängender Graph
Emulator
Gerade
Modul
Touchscreen
Software Development Kit
Softwaretest
App <Programm>
Elektronische Publikation
Default
Mobiles Internet
Prognostik
Übergang
Quellcode
Modul
Rechenschieber
Objekt <Kategorie>
Einheit <Mathematik>
Faktor <Algebra>
p-Block
HMS <Fertigung>
Softwaretest
Soundverarbeitung
Drucksondierung
Synchronisierung
App <Programm>
Spieltheorie
Computeranimation
Weg <Topologie>
Datensatz
Bildschirmmaske
Einheit <Mathematik>
Spieltheorie
Hash-Algorithmus
Bildschirmsymbol
Gerade
Softwaretest
Komponente <Software>
Elektronische Publikation
Spieltheorie
Prognostik
Spieltheorie
Übergang
p-Block
Datenstruktur
Programmierumgebung
Computeranimation
Klasse <Mathematik>
Mathematisierung
Computeranimation
Gebundener Zustand
Open Source
Datensatz
Prognoseverfahren
Spieltheorie
Migration <Informatik>
Äußere Algebra eines Moduls
Gammafunktion
Softwaretest
Parametersystem
App <Programm>
Videospiel
Elektronische Publikation
Datenhaltung
Spieltheorie
Übergang
Kontextbezogenes System
Elektronische Publikation
Objekt <Kategorie>
Rechter Winkel
Systemtechnik
p-Block
Retrievalsprache
App <Programm>
Mathematisierung
Implementierung
Oval
Computeranimation
Datenhaltung
Homepage
PROM
Unendlichkeit
Komponente <Software>
Repository <Informatik>
Last
DoS-Attacke
Maximum-Entropie-Methode
Normalvektor
Softwaretest
App <Programm>
Zentrische Streckung
Schreiben <Datenverarbeitung>
Dean-Zahl
Elektronische Publikation
Synchronisierung
Zwei
Spieltheorie
Rechenzeit
Prognostik
Übergang
Web Site
Dampf
Rechter Winkel
COM
Gerade Zahl
Restklasse
Normalvektor
p-Block
Versionsverwaltung
Innerer Punkt
Punkt
Momentenproblem
Klasse <Mathematik>
Computeranimation
PROM
Repository <Informatik>
Hypermedia
Informationsmodellierung
Prognoseverfahren
Programmbibliothek
Weitverkehrsnetz
Kartesische Koordinaten
Gammafunktion
Normalvektor
Modul
Caching
Elektronische Publikation
Spieltheorie
Prognostik
Gibbs-Verteilung
Übergang
Elektronische Publikation
Marketinginformationssystem
Schlussregel
Emulation
COM
Einheit <Mathematik>
Geschlecht <Mathematik>
Mereologie
Ruhmasse
Versionsverwaltung
Faserbündel
Faserbündel
Kartesische Koordinaten
MPM
Computeranimation
Homepage
PROM
TUNIS <Programm>
Wurm <Informatik>
Open Source
Komponente <Software>
Repository <Informatik>
Metropolitan area network
Prognoseverfahren
Vorlesung/Konferenz
Zusammenhängender Graph
Radius
Airy-Funktion
Demo <Programm>
Modul
Gammafunktion
Virtuelle Adresse
Softwaretest
Elektronische Publikation
Datenhaltung
Konfigurationsraum
Gebäude <Mathematik>
Eichtheorie
Prognostik
Spieltheorie
Bildauflösung
Übergang
Diskrete-Elemente-Methode
COM
Meter
Gamecontroller
p-Block
Versionsverwaltung
Innerer Punkt
Faserbündel
Message-Passing
Softwaretest
Overloading <Informatik>
SCI <Informatik>
Prozess <Informatik>
Prognostik
Übergang
Ähnlichkeitsgeometrie
Computeranimation
Konfiguration <Informatik>
Komponente <Software>
Open Source
Emulation
Gruppenkeim
Einheit <Mathematik>
Ein-Ausgabe
Zusammenhängender Graph
MIDI <Musikelektronik>
p-Block
Versionsverwaltung
Innerer Punkt
Softwaretest
Suite <Programmpaket>
SCI <Informatik>
Elektronische Publikation
Adressierung
App <Programm>
Natürliche Zahl
Konfigurationsraum
Spieltheorie
Prognostik
Übergang
Migration <Informatik>
Teilbarkeit
Computeranimation
Übergang
Komponente <Software>
Rechter Winkel
Gamecontroller
Migration <Informatik>
p-Block
Bit
Klasse <Mathematik>
Kartesische Koordinaten
MPM
Code
Computeranimation
Metropolitan area network
Open Source
Komponente <Software>
DoS-Attacke
Kontrollstruktur
Zusammenhängender Graph
Meta-Tag
Software Development Kit
Softwaretest
Volumenvisualisierung
Prognostik
Elektronische Publikation
Gleitendes Mittel
Sichtenkonzept
Rendering
Dialekt
REST <Informatik>
Gruppenoperation
Gruppenkeim
Cloud Computing
p-Block
Innerer Punkt
Faserbündel
Retrievalsprache
Gruppenoperation
Kugelkappe
Term
Computeranimation
PROM
Komponente <Software>
Open Source
Schätzung
Speicherabzug
Zusammenhängender Graph
Skript <Programm>
Strom <Mathematik>
Modul
Gammafunktion
Spannungsmessung <Mechanik>
App <Programm>
Elektronische Publikation
Seidel
Volumenvisualisierung
Übergang
p-Block
Gruppenoperation
Quelle <Physik>
Gruppenkeim
Einheit <Mathematik>
Cloud Computing
p-Block
Versionsverwaltung
Bit
Momentenproblem
Kartesische Koordinaten
Computeranimation
Richtung
Übergang
Eins
Netzwerktopologie
Komponente <Software>
Softwaretest
Prognoseverfahren
Einheit <Mathematik>
Code
Stützpunkt <Mathematik>
Gerade
Softwaretest
App <Programm>
Namensraum
Teilbarkeit
Template
Spieltheorie
p-Block
Biprodukt
Teilbarkeit
Rechenschieber
Quelle <Physik>
Gruppenkeim
Verschlingung
Rechter Winkel
Server
Cloud Computing
Subtraktion
Quader
App <Programm>
Mathematisierung
Zahlenbereich
Code
Graph
Open Source
Datensatz
Spieltheorie
Endogene Variable
Programmbibliothek
Vererbungshierarchie
Zeitrichtung
Zusammenhängender Graph
Ordnungsreduktion
Datenstruktur
Modul
Universal product code
Systemverwaltung
Einfache Genauigkeit
Elektronische Publikation
Modul
Patch <Software>
Verschränkter Zustand
Gamecontroller
Zeitzone
Faserbündel
Router
Dualitätstheorie
App <Programm>
Klasse <Mathematik>
Versionsverwaltung
IRIS-T
Zahlenbereich
Code
Computeranimation
Komponente <Software>
Open Source
Last
Informationsmodellierung
Softwaretest
Fermatsche Vermutung
Spieltheorie
Zusammenhängender Graph
Skript <Programm>
Airy-Funktion
Modallogik
Drucksondierung
Fehlermeldung
Elektronische Publikation
Default
Datenmodell
Mathematisierung
Prognostik
Objektklasse
Migration <Informatik>
Variable
Emulation
Einheit <Mathematik>
Anfangswertproblem
ATM
Modelltheorie
Vollständigkeit
Cloud Computing
Zeitzone
Softwaretest
Soundverarbeitung
App <Programm>
Maschinenschreiben
Mathematisierung
Schreiben <Datenverarbeitung>
Kartesische Koordinaten
Schlussregel
Elektronische Publikation
Biprodukt
Teilbarkeit
Raum-Zeit
Computeranimation
Objekt <Kategorie>
Domain-Name
Datensatz
Informationsmodellierung
Spieltheorie
Migration <Informatik>
Gamecontroller
Zusammenhängender Graph
Hilfesystem
Gerade
Leistung <Physik>
Tabelle <Informatik>
Arithmetisches Mittel
Softwaretest
Objekt <Kategorie>
Informationsmodellierung
Prozess <Physik>
Prozess <Informatik>
Spieltheorie
t-Test
Programmbibliothek
Gerade
Computeranimation
Soundverarbeitung
Softwaretest
App <Programm>
Datensatz
Einheit <Mathematik>
Last
Computeranimation
Softwaretest
Quader
Migration <Informatik>
Mereologie
Ruhmasse
Faktor <Algebra>
Zusammenhängender Graph
Kartesische Koordinaten
Inhalt <Mathematik>
Datenstruktur
Entscheidungstheorie
Geschwindigkeit
Randverteilung
Umsetzung <Informatik>
Zahlenbereich
Code
Computeranimation
Homepage
Eins
Benutzerbeteiligung
Multiplikation
Prognoseverfahren
Spieltheorie
Randomisierung
Zusammenhängender Graph
App <Programm>
Kraftfahrzeugmechatroniker
Sichtenkonzept
Güte der Anpassung
Arithmetisches Mittel
Gamecontroller
Projektive Ebene
Faktor <Algebra>
Garbentheorie
Refactoring
Eigentliche Abbildung
Gemeinsamer Speicher
Mathematisierung
Kartesische Koordinaten
Quellcode
Elektronische Publikation
Computeranimation
Eins
Benutzerbeteiligung
Prognoseverfahren
Spieltheorie
Skript <Programm>
Zusammenhängender Graph
Refactoring
Softwaretest
Sichtenkonzept
Mathematisierung
Kartesische Koordinaten
Code
Computeranimation
Benutzerbeteiligung
Rechter Winkel
Last
Gamecontroller
Zusammenhängender Graph
Bildgebendes Verfahren
Standardabweichung
Softwaretest
Benutzerbeteiligung
Prognoseverfahren
Graph
Rechter Winkel
Atomarität <Informatik>
Mustersprache
Programmverifikation
Gamecontroller
Quick-Sort
Computeranimation
Softwaretest
Benutzerbeteiligung
Prognoseverfahren
Rechter Winkel
Template
Gruppenkeim
Garbentheorie
Kartesische Koordinaten
Gerade
Computeranimation
Verzweigendes Programm
Kartesische Koordinaten
Routing
Modul
Teilbarkeit
Computeranimation
Homepage
Benutzerbeteiligung
Rechter Winkel
Mereologie
Injektivität
Zusammenhängender Graph
Information
Refactoring
Aggregatzustand
Softwaretest
Suite <Programmpaket>
Subtraktion
Benutzerbeteiligung
Prozess <Physik>
Natürliche Zahl
Injektivität
Zellularer Automat
Systemaufruf
Kartesische Koordinaten
Binder <Informatik>
Konfigurationsraum
Computeranimation
Softwaretest
Suite <Programmpaket>
Orbit <Mathematik>
Einfache Genauigkeit
Kartesische Koordinaten
Elektronische Publikation
Computeranimation
Konfiguration <Informatik>
Netzwerktopologie
Spieltheorie
Migration <Informatik>
Zusammenhängender Graph
Refactoring
Normalvektor
Umsetzung <Informatik>
Bit
Punkt
Web log
Gruppenkeim
Versionsverwaltung
Kartesische Koordinaten
Komplex <Algebra>
Computeranimation
Internetworking
Prozess <Informatik>
Softwaretest
Zentrische Streckung
Suite <Programmpaket>
Parametersystem
Schießverfahren
Dokumentenserver
Winkel
Kontextbezogenes System
Biprodukt
Ein-Ausgabe
Teilbarkeit
Rechter Winkel
Heegaard-Zerlegung
Server
Garbentheorie
Overhead <Kommunikationstechnik>
Pendelschwingung
Programmierumgebung
Subtraktion
Gruppenoperation
Klasse <Mathematik>
Mathematisierung
EDV-Beratung
Sigma-Algebra
Benutzerbeteiligung
Knotenmenge
Multiplikation
Reelle Zahl
Spieltheorie
Stichprobenumfang
Zusammenhängender Graph
Inhalt <Mathematik>
Datenstruktur
Soundverarbeitung
Benutzeroberfläche
Graph
Systemverwaltung
Einfache Genauigkeit
Elektronische Publikation
Last
Mereologie
Codierung
Trennungsaxiom
t-Test
Schreiben <Datenverarbeitung>
Kartesische Koordinaten
Homepage
Domain-Name
Arithmetische Folge
Reelle Zahl
Grundsätze ordnungsmäßiger Datenverarbeitung
Stichprobenumfang
Vorlesung/Konferenz
Zusammenhängender Graph
URL
Information
Refactoring
Standardabweichung

Metadaten

Formale Metadaten

Titel Get started with Component-based Rails applications!
Serientitel RailsConf 2015
Teil 27
Anzahl der Teile 94
Autor Hagemann, Stephan
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/30664
Herausgeber Confreaks, LLC
Erscheinungsjahr 2015
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Component-based Rails helps you regain control over your sprawling Rails application. It helps you structure your new Rails application in a way that it will stay more manageable longer. It helps you think completely differently about writing applications - not just in Ruby and Rails! This session will help you pass the initial hurdle of getting started with component-based Rails. While there is nothing really new, there is a lot that is just a little different. We will go over those differences so your start with component-based Rails is a smooth one.

Ähnliche Filme

Loading...