Merken

What Comes After MVC

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and and in the end the end of this and they're very welcome our our sample happened starting off the craft encoded the track at the conference so let's just are some like here's an example of how a rule that started so a typical example of an example using a design talk and I'm not interest in this example I want to this into like the real world schema that I saw a quiet and it's a little more complicated it's not a mistake or a joke like this is a mature domain model for a complex real problem and this is even close to the full thing you need the user model in there this is what those pretty little examples look like after a year or 2 or 5 exposure reality and I think we also succeeded by promoting design conventions like just put your coding these folders connector models with Active Record use NBC but other apps have gotten bigger and bigger and older and older the structure has been enough to support them microservices and engines and jens they break up code and I think that for most apps more than they help I think model it's a great and I wanna make good ones today I wanna talk to you about what happens next what happened after you've use rules generate a few dozen times and after you have migration the only reverses the previous migration because future change and then change back weapons left your tests we creeps above 1 minute and 10 and 20 and there's no end in sight what happens after you've got a long argument lunch about factories and Marx like you're holding grudges afterward and nothing is settled what happens with a small feature just doesn't seem possible like making a smaller factor hatches tests we're whatever's when NBC isn't enough to organize your code so welcome on pure hurricanes Thomas you can solve the deadline
were small happy consultancy in Chicago and I've touched dozens of rules after last couple years have previously worked in genuine PHP at 1 place of 100 small sites in other places with huge Rails apps that are not aging so
well and as a mentioned on the title slide camera so please don't post pictures of the online it's an interesting personal situation just do new favor facts and you don't even need to take of the screen and put all the slides with verbatim speaker notes in case I get stage fright uh up after so the last sort of have a link to that and you might want closure laptop because if you think I'm speaking fast now now coming keep the space up order move through a lot code and unfamiliar concepts and I think you want this out because there's a cat difference flat so like here's the plenary talk about because we have now and we give to root that's using tools for our breaking it down in different ways organ explore what those rules implicate fur coat and I'm and with some resources and tools you can use some links to more places you can see good code the techniques the talk about applied all of our code but almost all the examples are going to be from the model error because that's where see most of the other problems in code quality like we have skinny controllers which are greater than models just grow and grow and that big ball of mud that we draw our models like Hassan tests but it's unreliable anyways it frustrates our efforts to add features or write good code I think Active Record is a really well written genome with a lot of benefits for making acts like we have an not query builder of factory girl and we can easily get any model anywhere anytime what everyone retrieved from a persist to the database and validation of right there are models to the easiest time and it's find change and models are just obvious to put the related code but all these new early benefits is mirrored by a long-term drawback was amazing tools let us put off painful things into we've painted ourselves deep into a corner and without hierarchy we cyclic dependencies where we have to 3 objects in an invalid state before we can create the other objects and they need to work there was 1 in that real world example sliding didn't even see because these things are really hard to spot always accessible means any part of our code can create retrieving destroy models of functionality drifts often hooks and triggers and it's fine we have a whole young could ahead but this is the source of that fear you feel when you realize you don't know what other code might it's some model of yours or when you don't know what's going to be behind that method you call a mall finally all that part of it easily accessible database is sort of the ultimate global variable it's not only shared between processes that share over time and maybe even with different apps entirely through integrating with a legacy systems with validations of our code it's really easy to insert invalidated our have models confused with tons of conditional validations on edit validations and then later discover that records you just retrieved from the database were retroactively made invalid you can't save them back at a real fun about and that home for code keeps getting new wings attached to it Active Record models already have business logic and validations and trigger SQL queries then serialized adjacent so why we have them render some HTML some you may be their own form or send e-mails like more and more they just become a junk drawer for any kind of vaguely related code I'm thought a clean not saying that Active Record sucks I think it's great code but all the good features the Active Record design pattern make it easy for us to write a lot of bad code and we get stuck with no vocabulary effects were doing this pattern and so what lies everything painful after a year 2 and q we solve it with some complicated scheme that we use our code looking weird in over design I wanna talk about how to get out of this track will start with some really bad real-world code it's mine decompose according to to explicit rules and talk about how to test the pieces the improvements were going to make a incremental can be used partially and can be reversed if you think they're about idea in if a new developer joined the starts code without knowing the rules it's not like your code bases can instantly burst into flames so it's given that example project I wanna show you the what is
Scheiber is a website that archives mailing lists the name is a portmanteau Chicago and library because I'm from the 1 and I love the other so here is the overview from mailing list about game design and development you need to be able to read it I know it's tiny but you can just see the shape of it that up top is a table 4 numbers at each month counted how many threads in messages there are and then below is a big text description the list I really like reading mailing list discussions because there's a lot of smart stuff out there and I started Scheiber help with that and also as an excuse to play with different databases and Ruby itself and all of that when I started I had no idea what I was doing thunder trying to design construct some the 1st all code I wrote so if you look back and you get repo after the talk will be really obvious that that's the case on the other hand it doesn't look a lot worse than what I see a clients and I use cyber is approved ground to experiment tho design for a year and I'll be sharing the successful results with you today so cooking into 1 of those individual months here's a list of all the discussion threads you can see 2 expanded and all of the tree of people replying down and then in an individual thread there's that tree repeated the top and just all the messages a big feature from is reading 1 discretion threads per page because I don't look through what a keyhole at 1 message and the click for 1 method in the click for 1 method on see everything it meant a lot of fun code those sorting in parenting messages back together or dealing with that data tried do that so let's jump into the code for messages yeah but I know
you carry it's the got object of the system and its I'm not to embarrass 0 because it's only 300 lines and Ising models that a 4 or 5 times that so let's zoom at the top is the start it doesn't hear from ActiveRecordBase but because Active Record was the only pattern I knew for database access is a fine example what Active Record classes turned into a after a while and how to decompose them it starts off with a bunch of accesses there's also the fields you'd expect and then there's a big projects and a method for normalizing suggestion that by removing all the like forward 48 re going that build up on your uncle for that e-mail about Obama fluoridating our water and then there's a factory method for instantiating messages from a hash and there's a lot going on so far so let's just keeps rolling down where there's the constructor which is really complicated and confusing our message the fetched by the database bypasses database here passed in is a big string we move from another message object is a real mess and it should be at least 3 factory methods like that the serialized but we can do even better than that so learning high that the distraction the call number variable is the unique ID for each message so it's really important but it's optional variable although at the end of the arguments and I paper over that by having an exception down below to keep the message from living in an unusable invalid state for too long and there's a nice idea working here the object shouldn't be seen by the outside world an invalid state and will find a better expression of that later but there at the end of next to extract some metadata like subject to instance variables so what how does that it call this method to extract metadata calls this load subject and then falls back to a placeholder for can't find 1 and then it knows if the subject looks like a applies enacted riots and it has another method that's instance-level the calls that class method are nested cargoes on on like this but we've already seen enough code that have examples for the rest of the talk and we're extract those clumps of related code that work on the same variables to objects called values I promised you to rules so let's talk about them and apply them to this code the first one is that values are immutable when we call the method we know will give us the same answer it did last time while like that message update or maybe we can ask its subject and then yield the sum of the code and then we look at the message again a clever new subject this is really closely related to referential transparency if you know that my constraints with that here but for example in the code you right now integers are immutable we have read you add 1 you get a new in for you don't update 3 we also use dates immutably adding and subtracting them to get new dates for metadata variable like posted at the changes but the date April 23 doesn't turn into some other day you can't turn Tuesday and Wednesday the variable in the value in are separate things could it's immutable like values cannot call code that's mule because then I can guarantee you will give the same answer if my expiration date would ask the user what plan there on it might end up giving us 2 different answers because the user changed account types or something the 2nd rules that values don't have side effects they don't do anything another piece of code might see besides return they don't read from an API they don't save to the database don't look at files on disk and update after another object they just return code that doesn't have side effects cannot call code that have side effects to use a man the termite mutability inside effects a transitive if a method uses code that mutates or has side effects than that method is mutable has side effects like if you've taken an now of vowel of non-violence and you hire someone else to beat up someone you don't like that is totally cheating on your of non-violence when we ask a subject for its normalized version it calls a method because and talk to the database at more than that would be the same to us is that the subject directly was talking in the database so we're take those 2 roles and we're make them real by extracting some values from that message code so here's the call number now to proper class since is the unique key free each message in showery really matters that these things are valid and correct you and enforces that validity with an exception of value is never about loud to be in an immutable state because if it's if it's immutable it can't ever change to a valid 1 and there's another reason to if an object can be invalid every method that uses that object has to wonder which it's getting real or fake because they'll act differently it's sort of a violation of a list of substitution principle finally I comma reasons agreeable gem called adamantium after the initialized method the whole object is frozen so that an exception would be raised anything tries to new call number if you've used freezing not in Ruby with objects there's a couple of a weird little edge cases and adamantium does what you'd expect adamantium guarantees are the mutability so well look at the 2nd value and take a message the it's the here's the front half of the subjects heard that really simple it just as a simple initializing the rap superstring and like all number a uses adamantium to enforce its immutability it also uses the standard libraries portable module to delegates some methods so if you ask a subject for its length trying sorry it just makes the string the wraps up do all the work so that also uses equalizer another great little gender takes a list of attributes and generates double equals another equality methods as well as hash if we need to use in the as a key in a hash it's kind of weird to me now how few of our classes in the fall Orioles code implement basic Ruby and interfaces like a quality hashing I think maybe that's a sign that were to framework dependent but I'm not really sure use the back half of subject which has those methods that we saw including that rejects and all the code related to subject lives in the subject object you can just ask a subject if it's normalized if you have a string floating around you have to go call class with that on the message so those are values we started breaking down the active rotted models into less complicated pieces by finding methods that use the same attributes and variables and pulling them out to their own classes like subject or the model is an awful lot about an active user behavior like a message knew what it means for a call number to be valid out we pull that out to this is the extract class refactoring and there's nothing special yet to make the class into a value will make immutable and remove its side effects that doesn't mean that it can't have a local variable that changes because that's usually an easy way to write method for from the outside you can even see that it's there we always get the same answer for the same arguments when we extract those values don't what the common review methods I talked about on subject and maybe some less common ones like if the value can be used in place of a string or integer subject can be used in place of a string than it'll want to start to end and finally really early on to be tempted to have acceded to have values coal return ActiveRecord objects because so much of our code lives there now don't do it a value can't guarantee it's immutable has no side effects of its calling methods on another object in my do exactly those things the simplest way to use a value from Active record model is to write your own getter and setter so that can be saved as a string of article on this if you were to do this is to use composed of in current rails within you have its API rows 5 and were missing a stronger France talk on that right now which I'm sad that will be on config the but for complex values that are made up of more values like a street address value might have a country value maybe I'll say that multiple columns or maybe it's own table that you reached by a foreign key you'll just keep model your tables the same way that makes the most sense you nothing changes in the database layer this is just 0 0 design and then only test values we do out without a lot of things because they're very small predictable if a value is built up out of other values is trivial for a test integrate down through them we don't use Moxon stubs can we don't need to ensure that side effects do don't take place and we only right assertions on the result of calling methods because nothing else will change additionally we can do really cool things like automatically generate property-based tests no I don't have time to get into that so that's values the immutable and they have no side effects they're often quite small I'm sure you guessed we're fill in the rest of this chart that but it's gonna go a lot quicker because only loosening those 2 restrictions so this is the halfway point of the talk on how you feeling kind of 3 in the deep end like you know my cat after
his death not but I I think generally people have this selecting too many confused faces but this is a good time to just kind of take a breath and if you have questions you should wave at me like right now mn yeah OK what keep so here's an e-mail it's another
value object it decomposes the rostering of an e-mail into other values we can see 3 strategies that work 1st message ID just think extracts the message ID headed to build a value and it's done that's all 2nd subject extracts the subject header falls back to a placeholder if the header is missing it also builds a value and then finally from extracts the from hadron returns a string I look to the code and I don't really do anything special the address so there is any point in making them more than a string not everything has to be a value we extract values because they help not because it's something we always have to do this is talk about practicality not about like religious extremism in our design all those values we saw didn't have identities if you have 2 subjects the Eagle doesn't matter whether you using the 1 variable a or variable that variable be and that's the same with the e-mail itself if all the headers and all the body is the same you are the same value as well as with people if you find another pure hurt and it doesn't matter that we happen to have the same name or we have individual identities even if we were roommates and have the same address or other attributes for the same would still have separate identities and the flip side of that is true even if I change my name my address my phone every every afternoon you keep new user table I still have the same thread of constant identity and mutability is right there in the definition of identity so we need something separate from values and we're gonna call those mutable objects that have identity entities but unlike values entities also don't have side effects so let's look at 2 examples 1st we have a new message class with all those value objects and more pulled out message gets pretty thin we initialize the call number that unique ID for each message that we extracted to a value and we just saw the e-mail the value that builds up more values like subject and sluggish the ID for the mailing list that this message belongs to we look at that example because it's not really different from call ID or call number but it's used in the Urals in headlines and we delegates methods down the values of the outside code isn't violating the Law of Demeter to get the data it needs the code that active message didn't change much at all but messages not just another value the e-mail on this long instance variables are mutable e-mail as we will because sometimes I find a better copy of an e-mail and a new archive and wanna reimport maybe as better headers or it fixes the character encoding issue because are all over the place and sluggers will can sometimes in e-mail gets CC did to mailing lists at once and I file them both in the same list instead of splitting them up so to make really sure it's clear if the e-mail the slogans Israel can change the music to replaced with the new e-mail a slug but the e-mail itself never mutates like it's the difference between a variable and the thing that's stored in in so speaking of list here's the
list entity it looks pretty similar the slug is the identity and the various fields are mutable there's a friend equalizer again because it's just handy 1 of the interesting things is how little code there tends to be an entities their job is to have an identity and rapid values not run a lot a code for the decisions about a business rules naturally get pushed down into our values and the dependencies of which classes we use full up into our and these were in the more this later if i think
OK entity is a fancy name for Active Record model and they're really close but they're not the same as the biggest difference is that Active Record models have side effects lots of them we call model we don't know if it'll trigger save overload association or call and some other web of models that have side effects but this talk is about that academic distinction so I wanna talk about how to extract entities from our models or at least make or models look more like entities because these rules can be applied partially and the father we go down this road the better code looks we can extract entities by following the steps we've already seen figure out what the identity is extracted many mutable values as possible and drive out side effects to adapters and shells which of the 2 things that I'm going to fill in a chart with if we use Active Record models as entities themselves we have a lot of side effects to deal with n here comes the part of this talk that's gonna sound ridiculous and scary remember you can follow this rule partially and even if you don't follow it I hope the rule helps you understand part of our models become so hard work with over time I think you should let your models called there or especially other models query methods lifecycle methods or your custom methods that have side effects I know this is really come out there as opposed to the standard Active Record design pattern but it works and if we lift up the side effects to adapters and chose to direct them from outside which I'll talk about in a minute we can still use all of active records wonderful features for queries and saving without Starling upper modeling what method when methods of side effects we really quickly lose the ability to reason about what's happening in why if all my Active Record models were little littered with calls to global variables what you would scream at that code but when I called global variables the database and hiding behind methods named finding create it just seems totally normal you so when we test these entities we use a couple more tools from a toolbox like factories and stubs before using them for more than a small convenience are code is probably poorly structured the famous example is when we use factor record perceive the factory girl to save 10 records to the database is just to test 1 small method on 1 model because all has so many side effects that rejected that the global variable in the sky that's the thing I'm most wanna get away from the real difference from testing values is that rather than only a certain method called return the right thing we can do assert that after calling a method the entity is now in the right state like if I update the user and change my phone number it's not that that method returns something I care about it that now the user has that phone number that's entities the mutable they have no side effects immutable values cannot commutable entities because then they would effectively mutate too so there's a natural hierarchy forming but you wonder like Haverhill I anything done if you can say things to your database are likely read from the Twitter API API never your app never does any work that the customers can see so we'll look at the bottom right corner of the grid where objects are immutable but do have side effects and I call these
adapters to the first one in its name for a Alistair Cockburn supported adapters a hexagonal pattern don't know why he gave it to name it seems to have 2 when shy is building those you unique all numbers that incorporates a Run ID a unique incrementing integer because shy readers and stored in SQL database I need some custom code to generate these in a transaction which involves a bunch of commands to inquiries from our readers database the left out a slide within a particularly relevant by showing you run IT service because it's the 1 I could tryin to fit on a slide and also because there's a copy of 1 in which you can guess with all the points space you know it's against the rules adapters renewable it was more convenient for the code that calls this to mutate by for it to mutate by caching the latest value this object is not perfectly immutable and that's OK Bruce tell me where to go and I could improve I following them but on occasion it's also improved by bending or breaking knowing what the real certainly help me decompose better obviously just dumping all this into call number dumping all of that into message but maybe I will use this code remove that last Peterson ability and animal for the future hold but for now I have the words to describe what makes this object more complicated adapted to be really thin wrappers around external services really stubs to figure out the result of calling an external service and will use marks for the specific purpose of making sure that that call to an external service was well formed and there's no other benefits and checking results because your test usually looks like you set up a marked to return some value and then you call into the adapter and you make sure there's only a form that is the value just marked so that's
adapters and we don't call are to then like values can call adapters values in entities don't have side effects so they don't call adapters adapters colander values entities otherwise the values nannies would look like they had side effects to design natural hierarchy that forms help keep pushing the situation where we want test 1 method that need to put several methods in the database 1st and then we have a code broken up in these 3 little boxes so let's look at the last box
which is not this box that's my other cat I learned from Aaron Patterson at every rose can't talking Captain itself so here's a worker at the
job they get skewed after the messages have been filed away it takes a slow the year and month which it calls him for sure that catches the total how many threads and messages the list had the month which fills in that table that we saw in the early screenshot the performance that is a little bit cute but it had to be to fit on 1 slide and all these methods are one-liners but rather than have a method with a couple local variables I broken up so I can write isolated test for the parts and then just 1 integrated smoke test if you square this is function composition this is closures training macro or F sharp spike operator and working from right to left inside out 1st thing it does is it the serializes that key and then next it loads of all the threads that month from the repository which is the adapter that interfaces to the database if threads were active record model the thread repose the adapter that would I would have calling the thread scope for cycle methods have time to dig into that code that threads are entities because messages get added to them over time or even removed if they were missed files so then a greater value from all those threads and then it starts that value back in the database this is a little procedural imperative program that uses the adapters to isolate the part of the code in each talk to the database that uses the entities to get it mutable things of value for doing some work and and then it records the result was look at 1 more little program if you haven't seen Sinatra before this is a router and a controller Action all wrapped up in 1 so when somebody gets at the page for a list to display all mount counts this is the code that runs it just goes on talks to some adapters and then it builds up as a result in rather than use another adapted to say things back to the database uses Hamilton return a web page but has almost exactly the same shape of the talk 2 adapters talked to the things that they give you and then do a little work at the end these
programs are called shells they coordinate all specialize object to do meaningful work it's their job to manage the dependencies in the classes they use make all the decisions we keep them because they don't have the restrictions on we give the small because they don't have restrictions on readability and side effects of the harder to reason about a show might not be a single method or a single object like the month worker and might have several methods like the web front-end has half a dozen euros at least when adding new code it's easiest to 1st at a 1st draft of the shell and then extract pieces out into entities and then values adapters according the rules we've talked about which is another way of saying that we can take the code we already right and break it down by these rules when it helps us to write the programs not all the time so
finally testing the shells we use all the tools in our toolbox here women talk much about fixtures but I only want to use them with real world input especially the stuff that's invalid otherwise we can end up in a situation where changing 1 piece of test data can cause more than 1 has to fail and we won't know if that test failure was intentional or incidental we might test on a result we get like that web page we rented where my check that the writing is in the database for that we told Sandra descended e-mail this is the only place where rewrite integrated and and tests alright 1 happy path where everything is wonderful to make sure all the potted talking to each other and then is needed alright regression tests when fixing a but I can't isolated but wanna think hard on those regression tests and try and break things down right more isolated code especially contract and collaboration tests and there's 1 thing missing which is the question mark that's what over your head which is like this is kind of bullshit because this looks nothing like my Rails out so I have to have 1 thing to my slide which is all
the more like now almost all of our code is mutable and all that has side effects especially database access it's not tiny little shells it's that big ball of mud worked hard to follow the path of execution horrified about how to write just enough tests where have all the bad things I open this talk with I promise to write tests for each of the types of objects so the UN now I
mean every test is integrated even the ones that lived in the folder called unit were integrated and we have used every trick into we have just have a little bit of confidence EcoWorx doing those big buckets of other code is where I took some Notes on grade book and talks like the ones on the slides and experiment an experiment until I realize I had I was seeing some rules for decomposing my code I have a lot more understanding of why more experienced developers gave a good advice stated and I'm really glad to share these rules and how you can use them to decompose your code into reliable comprehensible pieces they've worked for me on a nontrivial project and they've worked for me on client code you so here's some of the great tools are used along the way I wish I had time to demo them all up and on the right there some more example code you can look at the Shire up is up on my did have now and to factor offers geminate over this winter to the moderate expression these rules I don't explicitly follow them that you can see the outline of the shape of things to decompose the Cuban Lotus a alternative web frameworks that are just interesting for being small and trailblazer Data Mapper Ruby object member great for seeing through because that's organized really differently from the rails were used to seeing there's a trailblazer talk next up on the 4th floor or i so if you structure brain you can see how these rules apply and use them to understand other code on your own and has cooled down in a corner hiding I know it's really got an intimidating reputation but it's interesting because in it everything is immutable and side effects explicitly encapsulated in a way that's just not possible to do and repeat ethic if you work through a beginner course a book it'll teach you about programming in general but then also about Ruby lastly I know I'm not the only person experimenting along these lines I certainly right all those nice gems if you have or you want to please get in touch with me I think there's a lot of room for us to experiment Ruby on Rails to get everyone's AP a lot happier as they get bigger the experiments that we do you expand what it means to be idiomatic Ruby and they give us new tools and new understandings so all the slides with comprehend speaker notes are available right now and if you thought this was interesting you can sign up to gets more details and examples as I have a little fun to catch up on sleep and I would really love to hear about your experiments however they turn out whether that's here by e-mail so there's my contact info this is then what comes after every C and we've got a few minutes for q so let me thank you all for your time and your kind attention to the end of the day and in the end of
Mathematisierung
Code
Computeranimation
Eins
Informationsmodellierung
Domain-Name
Weg <Topologie>
Datensatz
Reelle Zahl
Migration <Informatik>
Code
Stichprobenumfang
CMM <Software Engineering>
Rechenschieber
Multitasking
Biprodukt
Datenstruktur
Softwaretest
App <Programm>
Parametersystem
Güte der Anpassung
Schlussregel
Teilbarkeit
Faktor <Algebra>
Reelle Zahl
Information Retrieval
Prozess <Physik>
Randwert
Adressierung
Nebenbedingung
Schreiben <Datenverarbeitung>
Raum-Zeit
Computeranimation
Code
Mustersprache
Rechenschieber
Multitasking
Stützpunkt <Mathematik>
E-Mail
Softwaretest
Lineares Funktional
App <Programm>
Datenhaltung
Güte der Anpassung
Entwurfsmuster
Abfrage
Nummerung
Quellcode
Helmholtz-Zerlegung
Arithmetisches Mittel
Rechenschieber
Hierarchische Struktur
Rechter Winkel
Konditionszahl
Projektive Ebene
Ordnung <Mathematik>
Computerunterstützte Übersetzung
Aggregatzustand
Fehlermeldung
Algebraisch abgeschlossener Körper
Web Site
Subtraktion
Selbst organisierendes System
Mathematisierung
Ablöseblase
EDV-Beratung
Hierarchische Struktur
Mathematische Logik
Code
Datenhaltung
Data Mining
Weg <Topologie>
Datensatz
Informationsmodellierung
Bildschirmmaske
Reelle Zahl
Notebook-Computer
Softwareentwickler
Soundverarbeitung
MUD
Validität
Schlussregel
Physikalisches System
Binder <Informatik>
Quick-Sort
Schlussregel
Datensatz
Objekt <Kategorie>
Mereologie
Gamecontroller
Faktor <Algebra>
Term
Gewichtete Summe
Desintegration <Mathematik>
Computeranimation
Homepage
Netzwerktopologie
Deskriptive Statistik
Metadaten
Client
Softwaretest
Vorzeichen <Mathematik>
Mustersprache
Substitution
E-Mail
Gerade
Schnittstelle
Metropolitan area network
Softwaretest
Shape <Informatik>
Dicke
Cybersex
Ausnahmebehandlung
Versuchsplanung
Rechter Winkel
Einheit <Mathematik>
Zahlenbereich
Repository <Informatik>
Informationsmodellierung
Zeichenkette
Tabelle <Informatik>
Instantiierung
Objekt <Kategorie>
Subtraktion
Hash-Algorithmus
Wasserdampftafel
Klasse <Mathematik>
Mathematisierung
Automatische Handlungsplanung
Soundverarbeitung
Diskrete Gruppe
Datenhaltung
Open Source
Variable
Erwartungswert
Informationsmodellierung
Spieltheorie
Hash-Algorithmus
Datentyp
Programmbibliothek
Vererbungshierarchie
Thread
Konfigurationsraum
Attributierte Grammatik
Soundverarbeitung
Schlussregel
Elektronische Publikation
Modul
Chipkarte
Datensatz
Zeichenkette
Attributierte Grammatik
Faktor <Algebra>
Hill-Differentialgleichung
Resultante
Punkt
Adressraum
Adressierung
Versionsverwaltung
Wechselsprung
Parametersystem
Konstruktor <Informatik>
Datenhaltung
Systemaufruf
Zoom
Variable
Systemaufruf
Datenfeld
Ganze Zahl
Geschlecht <Mathematik>
Kategorie <Mathematik>
Projektive Ebene
Refactoring
Ising-Modell
Schlüsselverwaltung
Message-Passing
Standardabweichung
Aggregatzustand
MUD
Nebenbedingung
Web Site
Gefrieren
Zahlenbereich
Code
Framework <Informatik>
Datensatz
Message-Passing
Mini-Disc
Softwareentwickler
Mobiles Endgerät
Hilfesystem
Implementierung
Gammafunktion
Fehlermeldung
Validität
Mailing-Liste
Physikalisches System
Quick-Sort
Objekt <Kategorie>
Differenzkern
Last
Parametersystem
Verträglichkeit <Mathematik>
Subtraktion
Punkt
Wellenlehre
Mathematisierung
Adressraum
Klasse <Mathematik>
Zahlenbereich
Sprachsynthese
Identitätsverwaltung
E-Mail
Gesetz <Physik>
Code
Computeranimation
Message-Passing
Variable
Umwandlungsenthalpie
Code
Gruppe <Mathematik>
Trennschärfe <Statistik>
Nichtunterscheidbarkeit
Vorlesung/Konferenz
Thread
E-Mail
Attributierte Grammatik
Soundverarbeitung
Trennungsaxiom
Freier Parameter
Systemaufruf
Mailing-Liste
Packprogramm
Objekt <Kategorie>
Konstante
Heegaard-Zerlegung
Strategisches Spiel
Attributierte Grammatik
Extreme programming
Message-Passing
Instantiierung
Zeichenkette
Tabelle <Informatik>
Retrievalsprache
Nabel <Mathematik>
Computeranimation
Prozess <Informatik>
Faktor <Algebra>
Nichtunterscheidbarkeit
Figurierte Zahl
Softwaretest
App <Programm>
Datenhaltung
Entwurfsmuster
Abfrage
Systemaufruf
Teilbarkeit
Entscheidungstheorie
Datenfeld
Twitter <Softwareplattform>
Anpassung <Mathematik>
Standardabweichung
Lesen <Datenverarbeitung>
Informationsmodellierung
Subtraktion
Overloading <Informatik>
Klasse <Mathematik>
Soundverarbeitung
Hierarchische Struktur
Zahlenbereich
Identitätsverwaltung
Code
Homepage
Variable
Informationsmodellierung
Datensatz
Benutzerbeteiligung
Mailing-Liste
Reelle Zahl
Videospiel
NP-hartes Problem
Soundverarbeitung
Assoziativgesetz
Differenzkern
Mailing-Liste
Schlussregel
Nabel <Mathematik>
Objekt <Kategorie>
Datensatz
Differenzkern
Mereologie
Faktor <Algebra>
Modelltheorie
Resultante
Punkt
Quader
Zahlenbereich
Hierarchische Struktur
Code
Raum-Zeit
Computeranimation
Bildschirmmaske
Umwandlungsenthalpie
Code
Mustersprache
Wrapper <Programmierung>
Transaktionsverwaltung
Hilfesystem
Soundverarbeitung
Softwaretest
Datenhaltung
Eindeutigkeit
Systemaufruf
Schlussregel
Sechseck
Warteschlange
Objekt <Kategorie>
Rechenschieber
Dienst <Informatik>
Transaktionsverwaltung
Loop
Ganze Zahl
Anpassung <Mathematik>
Wort <Informatik>
Message-Passing
Resultante
Algebraisch abgeschlossener Körper
Quader
Gruppenoperation
Zählen
Web-Seite
Code
Computeranimation
Homepage
Datensatz
Variable
Informationsmodellierung
Prozess <Informatik>
Router
Thread
Optimierung
Algorithmische Programmierung
Softwaretest
Lineares Funktional
Shape <Informatik>
Dokumentenserver
Datenhaltung
Stellenring
Mailing-Liste
Elektronische Publikation
Rechenschieber
Rechter Winkel
Last
Mereologie
Anpassung <Mathematik>
Dreiecksfreier Graph
Gamecontroller
Serielle Schnittstelle
Computerunterstützte Übersetzung
Makrobefehl
Message-Passing
Tabelle <Informatik>
Resultante
Nabel <Mathematik>
Klasse <Mathematik>
Schreiben <Datenverarbeitung>
Web-Seite
Code
Computeranimation
Benutzerbeteiligung
Softwaretest
Prozess <Informatik>
Reelle Zahl
Front-End <Software>
Lineare Regression
Kontrollstruktur
Optimierung
E-Mail
Schreib-Lese-Kopf
Soundverarbeitung
Softwaretest
Schlussregel
Ein-Ausgabe
Nabel <Mathematik>
Entscheidungstheorie
Design by Contract
Objekt <Kategorie>
Rechenschieber
Kollaboration <Informatik>
Ein-Ausgabe
Anpassung <Mathematik>
Objekt <Kategorie>
Maschinenschreiben
Domain <Netzwerk>
Bit
Nabel <Mathematik>
Randwert
Desintegration <Mathematik>
Code
Framework <Informatik>
Computeranimation
Eins
Gradient
Benutzerbeteiligung
Client
Arithmetischer Ausdruck
Softwaretest
Einheit <Mathematik>
Font
Bereichsschätzung
Code
Datentyp
Rechenschieber
Äußere Algebra eines Moduls
Softwareentwickler
E-Mail
Gerade
Softwaretest
Soundverarbeitung
Shape <Informatik>
Datenhaltung
MUD
Schlussregel
Nabel <Mathematik>
Rechenschieber
Objekt <Kategorie>
Rechter Winkel
Information
Programmbibliothek

Metadaten

Formale Metadaten

Titel What Comes After MVC
Serientitel RailsConf 2015
Teil 68
Anzahl der Teile 94
Autor Harkins, Peter
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/30717
Herausgeber Confreaks, LLC
Erscheinungsjahr 2015
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Rails apps start out quickly and beautifully, but after a year features are a struggle, tests are slow, developers are grinding, and stakeholders are unhappy. "Skinny controllers and fat models" hasn't worked, and "use service objects!" is awfully vague. This talk explains how to compact the "big ball of mud" at the heart of your app into a bedrock of reliable code. It gives the steps to incrementally refactor models into a functional core and gives explicit rules for how to write light, reliable tests. https://push.cx/2015/railsconf

Ähnliche Filme

Loading...