Bestand wählen
Merken

Succession

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
thank you for all of the things we do that and so that the AV has been broken any other library here but I don't think we would be here but I was going to be the broker maybe so the solution to that was to not have presented I'm just near the display and at that point mostly the slides would show at a lot of slides I like 300 slides the pairing of threat but I use my prison denotes a lot a lot a lot so you I am and spent the nite figuring out how to print them at the hotel and this is a hard problem in computer science clearly because new exploit year keynote presentation to PDF but it gives you the great big slides which I don't care about at this point it's been really transition of so they can read so I wrote AppleScript to generate some Ruby code so that I could write a prior on like thing that would generate a PDF that I could send by e-mail to the business center at that clown balls of it in his grave of the word also you may know that they're going to be souvenirs after of course so that I just in case I realized afterward that I couldn't like reduced it by 50 per cent if had exported my PDF to PDs by end of braille print thing and then like a layout to up being that 3 in the morning I'm not thinking very close to did and think it's time free so
the there's this thing that we do know and I'm pretty sure we'll do it where you notice that this could over here and that bit of code over there are basically doing the same thing that the implemented differently and so you decide to switch everything over to use just 1 of
them and about 17 tests break remember that there is an edge case I and so you quickly patch conditional now 24 of failing you realize that there is missing the can and so you pull that in her now you about 50 failing tests and it turns out that there is a conflict between 2 different dependencies and so you swap them around so that they load in the opposite order now almost 80 tests are failing and by the way that encoding thing that the hallways happens at the thing where you are assuming that you've got 88 their UTF-8 but actually you're getting Latin 1 hour or is it the reverse side I don't hold unlimited you're trying use me that this and stuff that's not a part of the public API and so fuck it you use and I animal benches that blows up and it's something to do with unexpected Knowles and it's been hours since the test will last passing and now you're considering monkey patching no class and instead you do get research
hard and the most
difficult thing about refactoring isn't actually making the change its knowing where to begin and what to do next and how to make that change safely and you use the children's undergoes awaiting fall of Y as an excuse to talk about decisionmaking and refactoring the sign is incredibly simple but but it hasn't algorithmic component and this adds just enough complexity that we can talk about the real world refactoring principles that bonding you down in real world of and so the all the entire oldest text
this is all hardcoded into here Doc
trapped in a method and then wrapped in a class the very 1st thing you need to ask
yourself when you're about to refactor is whether or not you should do it at all In this case frankly the answer is no the sun hasn't changed in generations the could could be appalling and it doesn't matter the code works were never going to touch again stickin production and walk away so In order to avoid a spurious refactoring I have invented a spurious requirement we need to be able to continue to generate the song away but we've always done it in its traditional form we like that but in addition to this we want generate the song on with arbitrary creatures and so this establishes a perfectly legitimate reason to change the code it also gives us an information it tells us a little bit about the axis along which we need to support change we don't need infinite flexibility we just need this 1 type of flexibility now at this point there is another important question that you need to ask yourself and that is do you have texts and here again the answer is no because why on earth would you test a hard constraints so to protect against progressions up in here up into a
test and a very simple assertion and unsurprisingly this test passes which means that it is safe to start changing
things I that raises yet another question can you make the change that you need to make without any dirty hacks almost invariably the answer is no and so we have this new feature we 1 implement the very 1st thing we're going to do is not implemented the said we're rearrange the code where you find that flexibility that we need and then we're going to have the feature now it's almost never obvious upfront what that flexibility is gonna look like and so to start the process just take a moment to look at the
code for a bit notice stuff see what jumps out at you look for things in the code that you don't like and then pick 1 thing at and because the thing I hate most of the thing that I understand the best know what most people remark on here is all the duplication of string there
is duplication between versus
there's duplication within verses but it's not exact duplication the bits that change our all embedded inside the bits that stay the same and so it's called so seconds great big here Doc which
makes it really hard to deal with a small piece at a time and the 1st change make is to introduce a little bit of indirection I need
to take tiny steps on change 1 small piece at a time and for this we use a case statement with a branch for each 1st
so this means that we have to look over the range of verses join them to get the full lyrics and you can do it all in the same method that we only really care about the case the statement and the middle 1 step further and isolate it into its own method and finally we can start touching individual strings so I wanna do is tease apart the bits of vary from that's the same thing In other words some of this is template and some of it is the and we immediately
run into the problem of naming things typically you extract that you name it if you get the names wrong it meet the code dramatically harder to understand which makes the code dramatically harder to change in the easiest time to get the names wrong is right now when we understand the least about the problem now of course in this case even if you get the names right it doesn't really help because we have everything all mixed together and so this may seem a limit on C-style
string formatting using the per cent method can keep really handy it provides a clear separation between the static part variations I like that it doesn't matter where in the string the placeholder is all of the data ends up outside of the template and we haven't had to name things if you finest each of the verses the duplication between versus has gone from being similar to being identical in all of the bits that vary a off to the side and it's the same for the application within the 1st each entire verse has all the time for the stuff on the right and on the left and awful flow data home right now this is a tiny change but it is noticeable even when squinting and this is the here now that we started out with we used a case statement to break up the individual verses with the strings unchanged and now dissected the strings in place to seperate the template from the data now you might argue that I just showed could run on the slide
and pretended to have factor is a little bit like showing the food around on your plate and pretending that you been kind of pointless I'm some people can look at duplication they can immediately see how to extract methods and objects and often I just can't tell 1st and so dissecting it like this gives me a little bit more information without forcing me to commit to anything prematurely and in this case separating the template from the data has made the algorithmic part a lot more obvious features grows
systematically adding repetitions and find it stops abruptly now most of the verses take this phrase they repeated some number of times passing in a number of different creatures no it's not a lot of code but it does
seem like a complete thought might like to name it the there are 3 very common strategies for naming things the 1st is to be led by using some fragment of the implementation like swallow to catch something equally concrete and a kind of name that quickly gets out of date you find yourself with a method in blue it returns the hex code for
right the 2nd strategy is to name it
structurally you have recurring line or incremental sentences middle phrase and this is the kind of name that is absolutely technically accurate and totally unhelpful the problem domain here is about phrases it's about a little old lady who inexplicably swallows of flight and then compound the problem by swallowing larger and larger creatures and this particular part of the song is trying to explain the reasoning behind your behavior is talking about why she would ever do such a thing as swallow a bird a dog or a couch in other words the motivation 32 called motivation some number of times each time with
different data now ignore the fact that cows and goats some again the predator in 1 verse becomes the prey in the next and what we really want is a single list so that were not writing everything twice repeat turns out has innumerable method that conveniently yields each consecutive pair given a list of
critters loop over them passage where the motivation at the joint it into a single string and the strength of code also seems like a complete thought and I'd like to name it here we're talking about a sequence for a chain of events is described a sort of bizarre food chain so the
algorithmic portion of the code is all isolated into these
2 and there is a trade here we've taken something that was blindingly simple and with complicated we paid a price and we've gained a number of benefits we've isolated as small and very cohesive piece of code wave named an important concept the food chain and was what this implementation shows the bones of the algorithm it expresses the underlying structure of an essential piece of the song the structure was indiscernible when everything was just straight up straight so 2 things just happen
we extracted and named the algorithmic piece of 0 wow that was to us and when thing didn't happen we did use it anywhere technically this is called a parallel implementation that sounds very fancy but it means that I just didn't know what I was doing and I don't wanna screw things up on while I was thinking about and after making up a parallel implementation you should be able to just swap in seamlessly it will just work and sometimes it doesn't hear it just failed so think that there's something that we haven't understood yet about the food chain it turns out that 1 part of the chain is not
like the rest of the so what you will usually see in a code base when you have a rule with an exception yeah the conditional there
is a kind of problematic in the foot in the door in way you have a conditional you blink you have 12 somebody's gonna get hurt but with a context of a refactoring conditionals can be a useful tool 1st create the conditional the name what it represents and then use what you learn to make a decision about the next step now that sounds deceptively simple and there are a couple of false the conditional itself should contain the smallest
possible difference that makes sense if you think about it if something is the same in both
parts of the statement it's not really conditional on anything and so if we keep just the Wrigley bit of the spider than theirs nothing to put in the house French now you could draw that that might lead you to think that you're naming just the exception you're not the conditional red represents 2
variations on the same concept the rulers 1 variation the exception is another you're not naming 2 different things you're naming 1 single idea so the Sun were talking
about the critters distinctive features or some sort of qualifiers justice hum critters aren't all that distinctive a special if you leave only the bit about the spider and the name will almost inevitably end up being about the spider if you name a fragment of an idea it introduces not just in direction but in this direction this is a magic trick it gives you an illusion of understanding and the sort of deception makes it very very difficult to refactor so we're forcing yourself to command our consider the symmetry you name the whole concept of this method needs an argument prey is not the right name here praise about hunting this has nothing to do with 1 animal killing another 4 so this is about the crater itself take a moment to look at the conditional it it contains the smallest possible difference it's symmetrical containing both the exception the name doesn't misinform it's about a general concept in the song notice but the result of the method depends solely on the argument that past yeah this method could live anywhere could be a global function for all we care doesn't have anything to do with the so that this could a string and there's more stuff associated with which decorated with more behavior instead of passing the critters to the qualifier method we should inverted and send the qualifier message to the printer and to do that it has to be an object
and the data that cannot be extracted from diverse you of all the critters in the initializer the predator and prey are now no longer just strings the objects to which we can send messages and notice of once we found the critter object the conditional just went away you won't always be the case don't be afraid to introduce something that makes you feel of the refactoring is about making the code pretty is about understanding the problem that are and sometimes Abigail a bit early to get clean eventually so the motivation amp and it was so nice just a moment ago and now not so much this chapter sticks out not terrible but it is too much information at the wrong level of abstraction user into the nitty-gritty details and motivation Method shouldn't have to care if we extracted from have to name it the only thing I could come up with the kind of works is at that that so I will not tell you how long they spend in the source before I came up with it and worse ambivalence part 3 times I mispronounced it every time you know I just realized a few days ago how you actually pronounce that so at that since this is all about the critical angle for the class of and this is pretty good a lot has happened we tried to
swap in that parallel implementation and we failed focusing relentlessly on a small symmetrical difference isolated a meaningful idea and the idea was the seed of a tiny objects the crater this abstraction was not at all obvious at the start but now having found it and needed it feels inevitable so now are parallel implementation is finally complete we can
look at the case statement in the original implementation identify the algorithmic repetition and then swap it out with the call to this new implementation and this time changes seamless this test passes and this is better the case statement has gotten noticeably shorter than was always ended up with more code and more complexity and actually illness and continued their 2nd squinty thing of that's all class except the 3 little little lines of credit the pipelines so to be fair this is pretty mild complexity this right nothing here that you can understand even if you were just a little bit wrong this whole time we've been dealing with those duplication the strings of the song but it wasn't
obvious duplication was kind of we've been handling it indirectly from the edges when we started out there were fragments of plausible duplication throughout the case statement now there holds honks of
unmistakable duplication even the data has gone from being mostly a jumble to having a recognizable patterns it's tempting to focus on that same this to extracted and to give it a name resist that temptation for as long as you can identify the smallest difference see if you can make it go away and then ignore it and look at the remaining differences no difference on the 1st line is the name of some critter we've got a bunch of critter objects we just need to find the right 1 and then get the name of this take this tiny difference and make it the same everywhere and we can norm and that leaves us with 1 last difference between a different what are the key statement and this 1 is something that we do not yet named the again this is about the crater there's kind like a little bit of a commentary on the side so will need to pass more data or or creating critters and then use that abstraction in the case statement and now this too is identical and we can ignore it something interesting has happened all of that sameness that we've been ignoring can collapsed into a single block
sameness the is a trap the the distraction differences the parts that interest are interesting because the fragments of some larger idea you want to encapsulate the concept that varies not the concept that stays the same once you've encapsulated the differences in the same as either evaporates or it condenses into something obvious so all of this started with identifying duplication as the
ugliest best understood problems that interaction in order to be able to start dealing with individual strings and then encapsulated the algorithmic portion of the song discovering the critter object which is tiny and very very cohesive and finally focus on all of the little differences between the different cases making them go away and allowing us to collapse the entire on set of identical cases but we're not done yet we
start out with a gigantic string with extracted and extracted and extracted and we spent a lot of time down in the week that would be really useful to take a step back and look at the bigger picture so
this is a song that has 5 methods 3 of them a private all of private stuff seems like it could be its own thing as on does actually all only old code and there is a test will blow but we ignore it for a moment just focus on this parallel implementation before calling this from song we have to do a cult wild 1 thing mainly of the has to actually work was the test will hold on and this doesn't actually work I wanna do a 2nd thing that I wanna make the API of that class the API that I want and I'm only doing that because it's a hassle to fix it later and it takes longer and I only have 14 ministries and you do that 1st of the any other changes can wait until we've integrated because then when we run it on the test will have a back self the reason this is not working out is that the verse and chain methods called last ion on critters and diverse object doesn't know about critters pretty easy to fix the set some initial i'd like zation logic and then give the reader and with this change verse has with what it says what it needs I'm actually worse has more than what it means to delete all the critters adjusting the critters for that 1st and this has implications for the API the class known as the person change both take I is an argument we can get rid of the parameter instead get i from the size of the critters that doesn't fix the most egregious thing about the carried this class this is not the versus 1st this is the string representation of the per-subject now a Ruby idiom for that which is to ask which is very nice and make the public API perfectly reasonable especially if we make the last 2 methods private so to swap the parallel implementation into the song class replaced the call to the old verse method with a call to the new class of and you don't actually have to call to us here because joint will do that for you so you can delete all the old methods yeah this class of the test we now have 3 tiny objects each 1 is focused and cohesive the crater is minuscule it's basically a tiny wrap around the raw data that we initialize it went no song classes a little bit bigger than most of this consists of the array of critter data in this class knows not very much for maybe 5 things it knows what the ROC written it is knows how to transform the data into critter objects implicitly it knows who eats whom in the food chain because it's a border of raw data in the array it knows how to instantiate persons in us how to combine verses into a complete song it no longer knows what those verses are or how the constructed that is the domain of the 1st class which is significantly more complex than anything else but in this curve this class knows how the sausages made it knows which verse should be long Beach switch 1st should be short how to combine the data into templates on how what the algorithm actually is for the food chain it was all that now I'm not saying
that you should always splits and things up into new methods and classes that can be useful to ask yourself this thing that I have for 2 different things what would they be if you can come up with an answer that's not too far fetched it could be worth exploring and you can always in line it if you hate what you get and so the 1st class is looking pretty decent from the outside of the spring growth on the inside the most glaring thing here is the case
statement still sticking around and it has some blatant duplication now as before ignore the same focus on the smallest difference create a small focused conditional for just this difference making sure symmetrical and the name In this context this is what the narrator is arising work recapitulating everything that has happened up until this point 2 verses where there's nothing to summarize isn't so backstory at the very 1st verse and nothing's happened yet so this thing to say the very last year little lady is that so it's not much to say about that either I'm having extracted the recaps the duplication to s can be collapsed and named and this is the incident but the verses about this is the main deal 2 s tell a pretty good story with all of the details relegated to private methods and so this is a pretty decent and division of responsibilities the blatant duplication is gone there are a number of smaller annoying things for example there are calls to last pion critters and that's totally redundant because the critters that stored in the versa already blast ICA's you can delete those this removes almost all the places where we reference guide on there's 1 reference left in the case statements so we can switch that out to switch directly on the on the critters length and another little thing is the 1st written list which is the main character of the person it would be really nice to name it so there is 1 more thing that I don't like governance squint at all the template he stuff notice that the templates are all strings their red when interpolating stuff that varies stuff that varies abstractions that tends to be all black and here there is what's during there's 1 thing here that's not black and it really sticks out it's a hard constraint you could argue that if it doesn't vary shouldn't even be data maybe it should be a part the template of the a couple of arguments for the using a abstraction here the 1st is that we have this exact string into places this is the aside for the flight so we already named it we have an abstraction for the other really good reason is that the whole point of making all these changes is that we might not even have a fly and syringes use that abstraction the versus looking pretty good at this point it has boilerplate set everything up then I'm to ask which calls that is what is called by the outside everything we care about in terms of the API and to as calls incident and recap and re capels changing calls motivation I can feel like
all of these indeed be kind of annoying into gift exist in significant changes are not worth worrying about all these tiny irregularities and duplications and inconsistency is the add up it's hard to measure the impact of 1 tiny change but the difference in terms of clarity and understanding the staggering so the code is pretty good I have 1 complaint left arm and that's the case statement in the very beginning I just added it as a way to sort of start getting up the strings I thought it would be temporary and I hate that it's still there so the final factoring is 1 of the
classics from the refactoring book written by Martin Fowler it's called replace conditional with polymorphism and this is a step-by-step recipe refactoring is not
about achieving maximum design pattern density and fj factory is about balancing simplicity and readability and changeability don't refactor because you're embarrassed about your code this is not about esthetics story refactor because there's some design-pattern you've been wanting to try out this is not an academic don't refactor because you imagine a beautiful future with if and what ifs and it would just probably really come in handy your guess about the future is as good as mine which is to say total shipped an we're more likely to be wrong than we are to the right refactor because you need
to make a change not a hypothetical change and actual change the whole point of the refactoring wasn't to make the code beautiful or satisfy some academic pitcher craving it was to fulfill the requirements in addition to the age-old version of the song the client wants to introduce a general theme song and an ocean theme song and I do recall there was something about this world the purpose of refactoring was to make this not only possible but easy so we need to evaluate the code from this perspective we need gamble to send in any set of critters right now about
the hard coded critters for the traditional version of the song and this is find the client likes the traditional version of the song must be able to keep generating it and all the code should still work they also want flexibility so this is a pretty straightforward change if we give the constructor parameter we can defaulted to the existing array of data and then loop over the argument instead of the constant and so this would almost work exactly the way you want it the the problem is that we're making assumptions about how many critters are going to be involved now that is also very easy fix we can live up to the side of the size of the array we still have a problem and this was not so easy to fix there's a hard-coded 8 down the verse class 1st probably should know anything about anything outside of that 1 verse to know about other verses should know about how many verses there are and we have a few options here almost freely
grows so let's talk about of on the 1 hand in addition to telling the versus
what critters use we could tell it how many total critters there are is no worse than hard-coding the date of but also better more or less equivalent would be to pass all of the critters and also passed by this this is even more knowledge about the big picture into verse which is unfortunate but on the other hand there a trade-off song knows a little bit less that could be going on another option would be for song to figure out whether diverse should be longer short and then pass some sort of talking to the 1st class which duplicates knowledge and now the 1st knows about the long and short song also knows about the long shortly both have conditionals rate of not great song should know about
long and short templates verse should know about overseas and so what we need is a little shared between the 2 someone who can know about um long and short templates and know how to make verses in what the we could have to really sort really stupid versus home we have this of so uh of short bursts or long verse neither would have to know about each other neither would have to know about the total number of verses as long as both versus have the same interface and the sun doesn't have to know which versus dealing with so we need to turn 1 burst
with 1 conditional containing 2 branches into 2 verses with to recap methods 1 for each branch of a conditional because of long words have the chain it also needs the food chain stuff so there's a bunch of common stock and we can duplicate it but that seems like a bad idea so we could stick in the short bursts a long burst can inherit from the servers and overwrite recap and divided each food chain now up in song we need to call this in between thing this sham and it will know about all the printers and it will switch and figure out which verses and then instantiate would whatever it needs to return some people would call this at will overengineering from 1 thing verse builder factory I I don't really care like 1st for and it totally works at so we used to have a
code that was incredibly straightforward we then ended up with code that is still pretty understandable definitely more complex mn everything used to be all in the same place now spread out across a bunch of tiny methods classes things we've trade simplicity for flexibility have we done it right we should be able to generate lyrics with arbitrary criteria the simplest way to check is rather small text and when I say small I mean as small as possible but certainly no smaller the testimonies to cover all of our edge cases everything is relevant about the song everything that's interesting about the song but it should be realistic got give of redundant data and it would obscure things and distract from from what's important so instead of Y and the monkeys and lizards the data should be
simple and contrived and really really an interesting so with this data we should end up with these lyrics the 1st and last forces on both short the middle verses along and 1 of the middle versus has that extra qualifiers in we stick this whole thing in a variable insert that good does the right thing and it doesn't of which was a
surprise when I was preparing this talk of I it's pure luck that like contracted really silly uninteresting boring data happened to uncover above knows fell because we have the wrong indefinite article a means
when they zebra an alligator and it's not a big deal if this came up in production you can fix it in a heartbeat sell everything
patterns and select the identity of the can't but once said make the change easy and make the
easy change 1st refactor the code change the structure without changing the behavior keep doing this until you can add your feature without hacking it in not until find that the new requirement just takes a moment to implement and can can kind of feel like a bit of a miracle such a compact and say this he said almost this week he said was make the change easy warning this maybe hard that make the easy change
refactoring can feel like a little bit of a dark art the kind of is there's a lot of gut feeling involved to recognizing stuff you don't like that that that feeling that intuition is learned read about code smells watch cities tap genetics you can but this code do Covarrubias practice refactoring try stuff and chicken you get rid of it and try something else ignore the sameness for as long as you can don't name the fragments and slivers and shards of ideas name symmetrical differences in the whole concept it should feel like you're discovering your abstractions not inventing a good abstraction feels obvious in hindsight it's already there it's buried in your code and it's up to you to understand thank you thank you win 4 minutes supposedly that's pecuniary and wouldn't it be a big that the in
B separate commits 1 by 1 you can clone it downloaded look at all the changes it's actually looks slightly different order but that's because I kept changing things as I was working on the slides but it's all it doesn't really matter which order you do things and you'll usually end up in the same place I I'm writing a book within the Mets
from I made this pretty slide misuse like no if I think that's what it actually looks like
so I've failed to do thing where I design my slides afterward so I have this like odd red red thing going on OK the book is also it's also about of a children's song that is algorithmic it's the 99 bottles of beer on the wall and again it has that same algorithmic complexity that gives you the enough stuff difficult stuff that we can talk about good design and refactoring techniques without teaching you about investment banking and shipping containers and things like that and if you wanna practice refactoring a great place to go with that this is
not I uh I mean that there is a lot of the of the thing that exists and is that of a lot languages you can do and this is the real story behind exorcism is that once you've done in exercise go look at everyone else's code and start developing that sense of gut feel about what trade-offs there are what's easy hard to understand on and have a conversation with people about how that could could be more interest if the
but the the 1st thing you do need
NP-hartes Problem
Punkt
Hochdruck
Dichte <Stochastik>
Kombinatorische Gruppentheorie
Code
Rechenschieber
Gefangenendilemma
Programmbibliothek
Wort <Informatik>
E-Mail
Informatik
Serviceorientierte Architektur
Softwaretest
Patch <Software>
Bit
Refactoring
Mereologie
Klasse <Mathematik>
Versionsverwaltung
Ordnung <Mathematik>
Code
Computeranimation
Vorzeichen <Mathematik>
Mathematisierung
Zusammenhängender Graph
Komplex <Algebra>
Computeranimation
Nebenbedingung
Addition
Bit
Punkt
Singularität <Mathematik>
Klasse <Mathematik>
Mathematisierung
Kartesische Koordinaten
Biprodukt
Code
Computeranimation
Bildschirmmaske
Generator <Informatik>
Arithmetische Folge
Datentyp
Information
Ordnung <Mathematik>
Refactoring
Softwaretest
Softwaretest
Prozess <Physik>
Momentenproblem
Refactoring
Mathematisierung
Hacker
Code
Computeranimation
Bit
Nabel <Mathematik>
Code
Computeranimation
Zeichenkette
Spannweite <Stochastik>
Befehl <Informatik>
Bit
Mathematisierung
Verzweigendes Programm
Wort <Informatik>
Computeranimation
Zeichenkette
Trennungsaxiom
TVD-Verfahren
Befehl <Informatik>
Bit
Freier Parameter
Template
Mathematisierung
Kartesische Koordinaten
Datenfluss
Code
Computeranimation
Hydrostatik
Rechenschieber
Mereologie
Inverser Limes
Dateiformat
Hilfesystem
Zeichenkette
Objekt <Kategorie>
Subtraktion
Bit
Template
Mereologie
Zahlenbereich
Information
Refactoring
Code
Computeranimation
Sichtbarkeitsverfahren
Domain-Name
Sechsecknetz
Mereologie
Strategisches Spiel
Zahlenbereich
Wort <Informatik>
Gerade
Code
Computeranimation
Folge <Mathematik>
Folge <Mathematik>
Vervollständigung <Mathematik>
Code
Ereignishorizont
Quick-Sort
Computeranimation
Loop
Mehrrechnersystem
Verkettung <Informatik>
Mehrrechnersystem
Verbandstheorie
Zeichenkette
Wellenlehre
Zahlenbereich
Implementierung
Code
Computeranimation
Kohäsion
Open Source
Reihe
Verkettung <Informatik>
Algorithmus
Verbandstheorie
Datenstruktur
Kette <Mathematik>
Programmfehler
Verkettung <Informatik>
Mereologie
Implementierung
Ausnahmebehandlung
Schlussregel
Code
Computeranimation
Subtraktion
Konditionszahl
Refactoring
Kontextbezogenes System
Computeranimation
Entscheidungstheorie
TVD-Verfahren
Befehl <Informatik>
Bit
Spider <Programm>
Mereologie
Schlussregel
Ausnahmebehandlung
Computeranimation
Symmetrie
Resultante
Subtraktion
Bit
Momentenproblem
Code
Computeranimation
Richtung
Übergang
Symmetrie
Anströmwinkel
Kompakter Raum
Lineares Funktional
Parametersystem
Spider <Programm>
Abstraktionsebene
Ausnahmebehandlung
Quellcode
Quick-Sort
Objekt <Kategorie>
Mereologie
Verbandstheorie
Information
Refactoring
Message-Passing
Zeichenkette
Softwaretest
Bit
Subtraktion
Befehl <Informatik>
Abstraktionsebene
Klasse <Mathematik>
Implementierung
Systemaufruf
Komplex <Algebra>
Sommerzeit
Code
Computeranimation
Objekt <Kategorie>
Entscheidungsmodell
Gerade
Kette <Mathematik>
Zeichenkette
Objekt <Kategorie>
Bit
Subtraktion
Befehl <Informatik>
Rechter Winkel
Abstraktionsebene
Mustersprache
Mehrrechnersystem
p-Block
Gerade
Computeranimation
Objekt <Kategorie>
Subtraktion
Menge
Verdunstung
Nichtunterscheidbarkeit
Mereologie
Ordnung <Mathematik>
Computeranimation
Zeichenkette
Softwaretest
Parametersystem
Fehlermeldung
Bit
Kohäsion
Momentenproblem
Template
Klasse <Mathematik>
Selbstrepräsentation
Mathematisierung
Systemaufruf
Implementierung
Mathematische Logik
Code
Computeranimation
Objekt <Kategorie>
Domain-Name
Rohdaten
Algorithmus
Verkettung <Informatik>
Kurvenanpassung
Kette <Mathematik>
Zeichenkette
Quelle <Physik>
Nebenbedingung
Subtraktion
Punkt
Mathematisierung
Klasse <Mathematik>
Zahlenbereich
Benutzerfreundlichkeit
Inzidenzalgebra
Term
Division
Computeranimation
Endogene Variable
Elektronischer Programmführer
Gerade
Kette <Mathematik>
Parametersystem
Dicke
Befehl <Informatik>
Abstraktionsebene
Template
Systemaufruf
Mailing-Liste
Kontextbezogenes System
Fokalpunkt
Nabel <Mathematik>
Mereologie
Textbaustein
Zeichenkette
Subtraktion
Befehl <Informatik>
Mathematisierung
Modifikation <Mathematik>
Modifikation <Mathematik>
Klassische Physik
Term
Quick-Sort
Code
Computeranimation
Refactoring
Widerspruchsfreiheit
Zeichenkette
Addition
Punkt
Extrempunkt
Iteriertes Funktionensystem
Mathematisierung
Versionsverwaltung
Entwurfsmuster
Statistische Hypothese
Code
Computeranimation
Data Mining
Dichte <Physik>
Client
Menge
Perspektive
Faktor <Algebra>
Refactoring
Addition
Konstruktor <Informatik>
Loop
Parametersystem
Client
Klasse <Mathematik>
Mathematisierung
Versionsverwaltung
Code
Computeranimation
Kette <Mathematik>
Konfiguration <Informatik>
Bit
Total <Mathematik>
Konditionszahl
Modifikation <Mathematik>
Klasse <Mathematik>
Zahlenbereich
Bitrate
Quick-Sort
Computeranimation
Schnittstelle
Konfiguration <Informatik>
Generator <Informatik>
Verkettung <Informatik>
Klasse <Mathematik>
Server
Verzweigendes Programm
Wort <Informatik>
Faktor <Algebra>
Komplex <Algebra>
Code
Computeranimation
Kette <Mathematik>
Arithmetisches Mittel
Einfügungsdämpfung
Forcing
Computeranimation
Fehlermeldung
Bit
Momentenproblem
Mathematisierung
Nichtunterscheidbarkeit
Strebe
Datenstruktur
Refactoring
Biprodukt
Code
Computeranimation
Rechenschieber
Bit
Subtraktion
Große Vereinheitlichung
Abstraktionsebene
Refactoring
Mathematisierung
Ordnung <Mathematik>
Natürliche Sprache
Symmetrische Matrix
Code
Computeranimation
Rechenschieber
Computeranimation
Meta-Tag
Komplexitätstheorie
Umsetzung <Informatik>
Große Vereinheitlichung
Reelle Zahl
Formale Sprache
Computeranimation

Metadaten

Formale Metadaten

Titel Succession
Serientitel RailsConf 2016
Teil 81
Anzahl der Teile 89
Autor Owen, Katrina
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/31565
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Refactoring sometimes devolves into an appalling mess. You're chasing a broken test suite, and every change just makes it worse. An even more insidious antipattern is the slow, perfectly controlled process culminating in dreadful design. This talk presents an end-to-end refactoring that demonstrates simple strategies to avoid such misadventures.

Ähnliche Filme

Loading...
Feedback