Merken

So You Want to Start Refactoring?

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and the and and the hand welcome to use a 1 one-stop refactoring and my name is Joanne fully and enemy talk that the factory so just sermon opening question who a year has spent a significant amount of time working in a code written by other people the OK so most of you is anyone in US that most of the time working in only their own code again at the fusion of so
little bit about me and am 1 of those people that have pretty much only worked in other people's code and I'm I'm right now I suffer engineer company dc called can't actually and I started coating on the job of sort of thrown into a programming integer by my dad not knowing how to code feel bad for the boss and so this this means that I've learnt how to deal with other people's code before I've ever really learned how to write down the stretch which means that I've done a lot of refactoring before even knew that were actually didn't really know the word refactoring that seems kind of scary and until maybe 2 years ago actually have been coding rail since text this since 2007 and so we would only work in legacy code and ensure that and most of you have worked on lexical you know what I mean by just to clarify by legacy could I mean code written by other people and that that's been around a it's had multiple versions so touch by a lot of people you know a concerted develops craft over time so this is pretty crafty code we're talking about and then 1 little more bonafide about myself this talk is that 1 time my boss gave me a box a pop charts with my face on it
as sort of an award for refactoring an internal tool so if you do factor you to think about the real part of the face on them and those are real popular it's there and you can see seminal flavors and so what is
refactoring as is the million dollar question and probably some of you know it is probably some year talked out of that means here's a good definition I found this axon Martin Fowler's website for his refactoring books so refactoring is a disciplined technique for restructuring an existing body of code altering its internal structure without changing expert external behavior so I like this definition I think it's pretty precise without being too technical and just to break down a
little bit the idea is to not have any changed your users graph stays the same they don't even know anything happening but you have an improvement for your developers so you and your teammates other people that work in your code see the code getting better you know your users necessarily don't understand don't know that things happening the so 1 of the sort of quote that I think I like this idea of of refactoring is from a sort of hoity-toity architect named will not have
known as look or museum action or means and it's we must refuse to afford even the slightest concession to what is to the mess we are in now so in his little hoity-toity architecture world use talking about improving the future and building spaces that improve future but in our sense this is sort of like if our code is the mass in every latest state NASA does need to be a mass rather and we can fix it the so why would you wanna a
obviously mentioned 1 big reason is that your code is the mass and you wanna read and you want a fix it but and you'll see this question a lot especially if you work on a bigger team or more corporate team or a team that has a lot of external deadlines you get this question what would people like but matters CEO's refactoring will have time for that we need features right now I mean features all the time we don't have time to waste time on cleaning up world code classes so sometimes it can be hard to get management to prioritize cutbacks isometry to talk a little bit about why you wanna refactoring but you can tell these people deeply get them to agree to do that before we get into how exactly do so why would you wanna refactor
I see for big reasons here we have maintainability those of you that have worked on people's don't know that it's always easier to work and the people's vote it's well organized when you know what you're looking for is much easier to go find a body that you've seen before and it is good that you know where to find stuff it's easier to add features to code that's well organized you know that's that's in exactly in the slot and scalability there's 2 things here the 1st is the usual scalability and again it's a it's easier to make your code perform at when you know where things are when you know you're not accidentally making the same Database Calling 47 differ files and that is also in a refactoring helped make 13 scalable so this is sort of this beginners track and some of you might be beginner some you work with beginners it's much easier for new people whether they're be Newark new people too cold or just need people to your team much easier Don them onto your team when you opposition explain your code for 3 weeks from the start and I see some people nodding you know apart and flexibility and this goes along with with maintainability it easier to to do those pivots that people started photographer too much if you can see the coding wanna change you have to go hunted down before you start working on and sprinkling this is a good 1 if you talk to someone who just doesn't see the value in it it's important a sprinkling apartment clinical that to give carbon will change you spend way more time decoding is spend in your car so when up with the same as I 1 up with the same investment into your code you put into your car so now
he's convinced you're management that you think it's a good idea to refactor they agree with the beginnings of it of factor I know that it's actually time right now to refer to and so who here has come across the road that they could understand where that the poorly organized yet Austria and so if you're a beginner sometimes you come across a stone you think 0 I'm just a dummy if anyone was in the top before this wasn't the things you come across a nearly all honesty but I'm too afraid to ask I wanna make mistakes a lot of times because really is pretty pretty hard understand it's not just you it actually is the and and so I think this is something that's important to refactoring is to trust your gut and to know that if you think something looks weird chances are it might be a little bit weird so if you think in your in your soul you feel this time for refactor you might right and the here's some warning signs
if you're overwhelmed by balance specially but coming from a single part of the code you seen decrease performance this income a lot of factors that refactoring might help you pinpoint what some of those things are before they get to that if again a you person comes on your team and look to this code says that's what on earth is this you might have someone who doubled with sometimes you become there's like this what is crazy led by doing this these are good signs the chateau and you're gonna take a look at it might be time to do some spring cleaning and in games underworld winter is coming and and make sure that you get your harvest before which accounts for God and so on and but sometimes sometimes you don't catch these things on time
and then you end up like this guy you don't end up like this guy and this is these are signs that you waited too long you need to refactor right now and you probably should generate tests are increasingly hard to write but the point is now because I think that in all cases tested through the canary in the coal mine if writing tests for about vector writing test for new feature is increasingly hard because you're relying on market outside assumptions for requires a lot of extra pieces the set up and this into stub out before you can even tell something maybe it's time to think about how you structure that piece of code and I'd like to point out here that test can also be refactored just because I want you just a hard right of necessarily mean your co-teacher factory I mean that yeah the and I've also seen code that so poorly organized it's brought blocking progress is takes too long to write anything in the use of God Ugandan features there so that's a good sign that you should have gone back and respected and now is the time to do it so that you can like I said you more flexible and more scalable and things like that you're goes crashing that's probably a good sign that something is wrong again if it's session is coming from the same piece of code over and over again yeah production graphing might mean that you have a blog you might have about the colonized and the spread and the whole produced needs to be cleaned out of all these bikes so the mean of the
presentation here how do you do it there are a lot of different approaches to refactoring and this is sort of I'm gonna walk through how I generally approach it there's there's lots of different ways that you never done before it's sort of hopefully give you some ideas of how the 1st concept you have done before me because of using like and yeah so the 1st thing I like to do
is prepare so I have a spray that Hume's on past which is a French phrase that people use in cooking that's like you're gonna start cooking the last thing to do is to get all your supplies set up for you and start to measure at all of your ingredients but little balls get all your tool that lay out that way when you're like Stern's also misspelled estimator soft-clustering everywhere you really need to solve across kitchen you have to like run across everything burn everything's terrible so the recent refactor acknowledging that kind thing to make sure that you're not scrambling in the middle of watching stuff burn and you could players the some things that are important in this process the beating of your test coverage in the rough community we have a lot of cool tools to make sure that you have good test coverage is the time to get out those those covered reports is the time to look at and those kind of good quality metrics that I'm sure a lot of you is maybe 17 different kinds of and and and make sure that you have it on on all aspects even if you're a back-end developer if you're taking capillary factor you need to look at your your front and test the nature that they cover everything or cover as much stuff as you this is a good time to review functionality of what you're trying to a you're trying to refactor sometimes especially in your back and developer you might not know exactly how the front end works how people interact with idea databases this is just good practice a developer generally but this is a good this is a good time to do it system down with the product manager or the customer support person or even and this year developer that and I wanna than you and make sure that you know exactly how this goes both work and exactly what was to do it's hard to refactor and keep that end goal keeping up the same if you don't know at this and see 1 make sure that you have a really solid foundation in and what you're refactoring the yeah and then make sure you brush up on codes stop because sounds really important at a lot of people to make sure that this person you're working in a team that everyone is sort of on the same page and this is a good chance to make sure you know where your team expects what sort of trend you're moving during you if your team is really trying to move the logic added the controller into the model you don't do girI factor that puts all the the all the logic back to automatically your code that you know it's not really where your team is going so those are the kinds of things to keep in mind while you're doing I wanna point out that this point you're taking every factor of application code you don't wanna change tests wall URI factor and this is a pretty important point that was not fully explained to me on 1 of the big 3 factors that I was asked to do because I was a new but I didn't think to ask and the if you're keeping our your production of functionality the same fear and uses your test is going to be your safety to make sure that you actually keeping up their operating anything in you factor not making anything totally different so if you change your chest midway you have that safety net anymore you're safety net has been moved and shifted and maybe not all over there and you're still dangling from a tree over here so and that's a good way to to get your test covered up to snuff is dual beforehand because separate commit that pushed through I have better health coverage which is great just generally if you never knew refactor and that make sure that you have a safety net during tree factor and then like a month before it noise refactor tests so you are in fact a new task that but that is true don't change application code by refactoring test you want the same test the past beginning past the and if you've changed and you can be on a per cent certain units out How pleaded but you know enough so instead of this preparation done you're all set you have your your test coverage and that's all merged in and everything looks great maxing out to
do is go through the code that you're targeting an annotator but did so this is basically reading through and commenting anything that stand out he was years of that this is you know some people like comment some people don't these Council go ahead once you're done this is a good way to go through and highlights yourself this is the stuff that looked weird to me this is the stuff that looks that this is what I want effects and 1 thing and I that that I like to do sometimes this isn't doesn't work always is consider copying outside code back its use in the in the core of the looking at so if you're in a controller and your code is relying pretty heavily on the validation it but it's done your model not only consider copying the validation over if you can you having trouble remembering what it does for your having trouble seeing how all the pieces fit together and put in a comment you could take that when you're done you have to worry about making your code on dry or whatever but it sort of helps to see everything in front of you all at once they might even help you figure out that that maybe maybe that what discovery over belonged in intro all time seeing not altogether conserved help you with that is this also was applied but I think that's that's an important thing it's copying is in ways that you don't achieve it necessarily but you most copy intermediate and then and the last part is rename variables In methods this some of these will get renamed permanently will talk a later the summit isn't is for clarity for some 1st for an example see you're going through some control code and keep running into this method called clear Perón's like what what is clear parameter it maybe that's not a good name maybe at the end the effective use I really should be called clean grants or strong and or you know some other standard in here like what what is this and really know the 2 goods that method and you realize 0 it's actually removing all this crazy stuff and translated what so you go through the code that refactoring in you rename all the instances of the fixed for and by removing all the crazy stuff so every time you see it you know exactly would have unilaterally what was clear president you know is fixing the problem of knowledge and is stuff that's obviously too long of a name to keep the college you knowledge about the forever but it's a good chance to give yourself an explanation and in line that doesn't interrupt the flow of you understand the code while you're working on understanding is the key that's what you're trying to get at the end of a factor so make use of that your understanding what you're reading even if it doesn't stay that way forever allow yourself to sort of experiment freezing weird stuff you can watch it so what are the kinds of things you wanna look for when you're editing
and 3 of code smells like to call them could mass is a cute dog right for the masses to love it so lovable and what what's redundancies you know like redundancy the Ruby world or in any coding World Health ways to complex your code should be clear in non-repetitive what part of the code of more than 1 to 2 reads understand again this is the time duration trusted that don't just assume that because the took 4 reads understand what's happening that you're just a domain you didn't understand it probably was poorly written and maybe even if at the end you decide that nothing about that can be changed and it really just is a complicated concept maybe it needs more in-line commenting that's so that's just the thing to note yourself and you see any method that with blood and we don't need to go all the way crazy down and the like you next and have only 1 action per method but you would get closer to that you might have a method that's 20 gazillion lines long because what you know what would you the in that would do and those kinds of things yeah and then does any of it by leader could standards this is pretty simple reluctant tool that can help you find these things and this is a good time to mark those things down so what you don't want all these things you have nice annotated code so marked how do you do yeah you go
through and clean up because this is the part that's really the me of actually doing every factor and this is the part that might seem the most overwhelming if you've never done before so I like to recommend people don't start at the start at the top usually through reading through a file if you want to be annotated at you know where all the problems that you need to start the topic and start the easiest thing for you to deal then if it that's all you've done you still made an improvement so you have a bunch of instances of work temple someone using a single letter variable those are pretty easy really low hanging fruit you can go through and clean although that make up a command that all you do that's a great in fact you just made the code more easily understood for other people who come after the so tackle those small things 1st the foregoing working your way up to more complex and folks someone method at a time to make sure that nothing is repeated those are pretty easy things to do just pull stuff out and making methods smaller methods those kinds of things and I mentioned names before this is a good time to make sure that your method names makes sense maybe don't leave fix crazy brands by removing all the other stuff but maybe 1 renaming clean parameter strong something that is more indicative of what what it's actually doing pixel stylish as I mentioned that's a pretty easy 1 most of us can handle that even if you don't necessarily agree with half rockets versus not hash rockets you can do it we all know it that and we get a list here things get slightly more complicated simplifying conditionals is 1 of those things that is really important to making code readable and is 1 of the harder things were for people to do if you have to sit down and Ralston like truth tables elective and diagrams like stop it take the time to do it and Monday I like to do with crazy looking conditionals is to break it down if you have a bunch of bands or words were like nest things break each 1 down that you have nothing nested and nothing and it may be a repeating all your raising initials but helps to get a handle on what actually is happening and then if you need to you can build it back up that combine things as necessary but it might help you see 0 I don't actually need to check this for different times because I've in effect chapter this 1 time snide covered for half the yeah and and then the FIL the probably the most complex thing here is making sure that your code lives were truly belongs some of this is is teams are preferences like I mentioned some that like for example my team is is moving a lot of our friend and logic into JavaScript script which we all know how teachers feels about that I and that's if that's like the fossil you're going maybe that's what you need to do but if there's not an overwhelming preference for these kind of things then this is your time to sit and think critically about this actually makes sense here is this is this controller code actually important for specific yeah control action or easy integral to my model this is actually to be moved by model is this something is this really complex looking method is this something that really needs to live in my model or is this something that I can pull out and put into an asynchronous jobs job so that I don't have to wait for my model to respond to this crazy looking thing that I'm having trouble tuple find things like that our yeah are pointing think about when you're in this is that this is the kind of thing to work if you get to this point like to pay its true I don't feel like this really belongs here but I'm not sure where it belongs that's a good chance of Poland someone else protein is pair programming that's a good chance to sit down and say I do weird about this method being in here just something seems off where you think it could go up or sit down with someone and may be tried over here you see how those yummy test failed want to move it to the model CME test fail when you move it to your background model sort of feel about advantages of some someone else to help you get a sense of where something actually truly should it it's not a from
through some and ideas on how to actually approach doing it have a very brief case study so as actually showing the whole refactor on a little slide in a 30 minutes talk is not going to be very practical so what I did was I pulled out a small snippet of 8 and actually factor that I did recently and and I'm going to walk through it sort of illustrate the method that I was just talking about and some of the concepts this'll mostly just look like I'm cleaning up some code which I mean to be fair that separate that's a refactoring actually is but and none of this should be to mind blowing which is also good because the filling up my so this code was part of our science controller and you're trying to refactor small bit it and it snowballed into a very big refactor this is from the new method of someone signing
up for a free track so you can is look at the shape of this code and you can kind of tell it looks bad but the 1st line is really long really need to be that long we really need to have like methods chained together you see we have a bunch of like nested stuff with like unless in an instant if not just basically unless you want more than enough and we could see some single letter variables which are always horrible so we got the entered so here's my annotations I made for this particular bit of code you can see why why this long know the bet is why are we having terrain what operands sign object-oriented programming doesn't really tell me but what is the sign up wouldn't have assigned model this particular project so that I really know what that is it takes me a lot of like of 1 of another had the go and pull lecture code in my comments to see what what what exactly this is passing NASA nested conditionals scene where the variables were assigned this you variable twice what we do not for so all pretty ugly so I was addressing these comments How did how did I go through here so from easiest to hardest in this particular case it is going to do is fix the names to we a single variable single letter variables and made them actually useful so these user actually users in Asia actually accounts we only the username stupid and we simplify this conditional so this is when I broke it all out and and built a back together so we don't have on analysis and double nested things and and then probably the biggest thing that we did here a we're back to this brand signed up and for the 1st thing was to take a slight triple I change method at the top here that like does some crazy thing with the e-mail and I only down cases the 1st 100 letters still know why that was there but we did was we changed it so that it was just a front end validation which is really where this should have more want whole time making sure that sum is actually giving us a valid e-mail address and we don't need to do anything to it was the time by the time it gets to us and and then the very last thing was going back to the form of generating the sign of France realizing that what it was actually doing was creating a user objects In this renaming brands used as a real community brands user something that you have a built in understanding of of what that means GM for user at school pressure sign up I did know what was but principal reason might OK here's some music grams there will a strong brands on MA we don't but this is this is going to create a user of which is why in fact this is doing so renaming that what was coming out that form made it sort of more rail sea and easier for it for other people to understand so once I got through
refactoring this is what it looked like you can see that I also added in some explanatory comments which for things that that work were confusing for someone new to read but not that it necessarily change like we're checking this demo account I don't really know that was really why we're doing this i put in some comments what I found out you say we rename the brands here we made the variables useful variables instead of the a the you are and then the conditionals broken down here so that it's nothing is nested and nothing is using uh if not for unless which is always a little harder to understand in this case you can see you might notice that we're checking if existing user twice with some people might look at undergoing a that's not drive in this particular case we decided that check what they are too expensive and that the readability of this part of the code that trumps whatever we might lose by not repeat that without that the double NASA conditional was a little too complicated that repeating this 1 time 1 thing once was was property so something else is eating you don't always necessarily need to adhere to style to a hard if readability is your goal so here's
some other tips now gone through this brief case studies and test frequently this is why you have those taxes like winter added this test make sure your also testing manually if this is something on the front end or something that you can test manually this is I had to understand what the functionality was who doesn't cover everything even if you magically have coverage which you say you do I don't believe you again don't enter Tesla factoring please don't do it I didn't it my mistakes because poorly and commit frequently want to have a green what you make a change the change the change of variable names to something made more sense when you test just to make sure you do most anything up once a green commit push it open up for us they look what I did then you already have a factor so mature committing proclaimed away you break the tests here to go back to last in the green and I mentioned earlier tools like Google coppery could help you find and plays in your code that reconciled find places in your code that you may have missed that our code smelly and to give you something to start on those kind of things can help you at 0 this method is way too long nearly all I hadn't even noticed it looks totally normal to me and then considering consider pausing after a lot river changes so after after your test passed in year and the example giving of changing the variable names other passes say maybe you decide you want play only to be that he did it got review together merged play pool refactoring deployed also done then 1 thing with this last that L is when you're planning what to but to group together what to deploy together sometimes you run into 2 different ways to do it that sometimes you plan sometimes they don't work
so on 1 hand you have this lovely turtle who is trying to slow and steady previously through do little bit at a time and incrementally change that and is great sometimes what you need to do sometimes the structure of Europe the management on your team is such that it's easier to just grab a little bit of time here and there instead of trying to get all whole spread prioritize for for refactor so sometimes this is great you know noisemakers fast progress but that's OK it's still better than but on the other hand sometimes you work in a team where making everyone have a heads down like we're gonna work for an entire so we haven't been refactor maybe that's more useful for your team and all you know get all the changes done at once that's at cool if you were on team could is real and just to go back to the to the slow and steady for 2nd sometimes it's easier to even if you don't have to be express permission to like I'm going to refactor if you're touching abusive code 1st on sometimes will start like talk with the idea of leaving code better when you left it there and found that this is a good way to do that not only can you go and fix about the 1 like that's you you you make your test after nearly all I mean here this looks a little bit weird that's a good chance just say you have a timeline method and you fix the bug on 1 of the lines to be 2 minutes you can totally spend another hour maybe fixing up but at that a little bit and then it's nicer for the next person from the long did take that long you did not the Catholic paper refactors anything like that those are really the things that even brain areas can do uh but 1 way also sort of mention this with our example is that sometimes if you try to start a small change again really easily snowball you pull on 1 string the whole thing comes apart can really easily snowball into into refactoring whole bunch of stuff so keep that in mind if that starts happening in a prepared work fine commit the start were stature changes and go back to the way to have but time to Paris and more senior than you if it's something that's overwhelming and the back noise happened it does mean you're doing it wrong just means that code is complicated because complicated there's no around if you have things remember
refactorings not scary we do it all the time you don't even with called factor the simulator where new design patterns and then refactor that actually up after about 3 factor of the DSL I've never worked diastolic to know that you posted for domain-specific language had no idea what good practice work that's it was that it was a good chance for me to go and read about these things read about how the code is structured read about all the ways in which the code I was taking was breaking all of those rules and how to operate the rules in and product the and I would have learned any of that stuff I had this continue working in the code the way that it was and it's again with a linear code base not only because you're doing the things in the beginning when we talked about like fixing just and make sure you understand functionality but this is this sort of this is the sort of stuff that you can really sit down with maybe the person that wrote that code maybe a person background or a whole bunch feel that the person who most recently did a lot of or the most feared on your team taking a walk me through this and having some trouble understanding what's going on here so and that's a good way to sort of get refactor started and also to understand really really deeply what is happening but what exactly is happening here why is it structured the way that structure and how we make it better again test can be reflected to you're tester if you're not assessed use your test military might understand what this attesting that the chance of a battery package even if it's just the descriptions of your artifacts that's important over word things and these are already factors of the amazing some really small but like I said reductants Oscar and the thing to do especially for beginners is to go back to the projects of the 1st things that you coded I some really scary is probably the persons that you cardinality of inquiry for a while you probably read them and think I have this is a great example of you probably can't read some other people's code of encoding for twice as long as you have noticed I did he do that yeah so this is the practice of you do it yourself you don't so now you've learned all these things
that refactoring and you can go forth the effect the
you of some of the some of the things in and of some
Refactoring
Faktor <Algebra>
Refactoring
Code
Bit
Quader
sinc-Funktion
Versionsverwaltung
Code
Quick-Sort
Computeranimation
Komplexe Ebene
Software
Prozess <Informatik>
Benutzerschnittstellenverwaltungssystem
Ganze Zahl
Code
Wort <Informatik>
Optimierung
Softwareentwickler
Bit
Web Site
Datenstruktur
Graph
Code
Refactoring
Refactoring
Softwareentwickler
Datenstruktur
Quick-Sort
Code
Computeranimation
Bit
Gebäude <Mathematik>
Gruppenoperation
Klasse <Mathematik>
Ruhmasse
Raum-Zeit
Code
Computeranimation
Datensatz
Datenmanagement
Vorlesung/Konferenz
Computerarchitektur
Refactoring
Aggregatzustand
Bit
Abstimmung <Frequenz>
Große Vereinheitlichung
Skalierbarkeit
Mathematisierung
Pivot-Operation
Technische Zeichnung
Elektronische Publikation
Code
Quick-Sort
Computeranimation
Softwarewartung
Quelle <Physik>
Datenmanagement
Skalierbarkeit
Vorzeichen <Mathematik>
Digitale Photographie
Codierung
Decodierung
Refactoring
Quelle <Physik>
Punkt
Web log
Ungerichteter Graph
Systemzusammenbruch
Code
Softwaretest
Arithmetische Folge
Vorzeichen <Mathematik>
Spieltheorie
Softwaretest
Schreiben <Datenverarbeitung>
Güte der Anpassung
Technische Zeichnung
Vektorraum
Biprodukt
Summengleichung
Arithmetisches Mittel
Rechter Winkel
Einheit <Mathematik>
Zustand
Mereologie
Grundsätze ordnungsmäßiger Datenverarbeitung
Faktor <Algebra>
Refactoring
Subtraktion
Prozess <Physik>
Gewicht <Mathematik>
Punkt
Natürliche Zahl
Mathematisierung
Geräusch
Kartesische Koordinaten
Kombinatorische Gruppentheorie
Mathematische Logik
Code
Computeranimation
Homepage
Überlagerung <Mathematik>
Task
Netzwerktopologie
Informationsmodellierung
Einheit <Mathematik>
Datenmanagement
Schwebung
Code
Softwareentwickler
Schätzwert
Softwaretest
Lineares Funktional
Linienelement
Datenhaltung
Güte der Anpassung
Physikalisches System
Biprodukt
Quick-Sort
Unabhängige Menge
Funktion <Mathematik>
Twitter <Softwareplattform>
Debugging
Codierung
Gamecontroller
Refactoring
Verkehrsinformation
Sichtbarkeitsverfahren
Mereologie
Relationentheorie
Gruppenoperation
Gefrieren
Interrupt <Informatik>
Code
Informationsmodellierung
Variable
Domain-Name
Standardabweichung
Code
Gerade
Hilfesystem
Soundverarbeitung
Parametersystem
Güte der Anpassung
Validität
Ruhmasse
Datenfluss
Variable
Quick-Sort
Komplex <Algebra>
Rechter Winkel
Mereologie
Gamecontroller
Speicherabzug
Refactoring
Instantiierung
Standardabweichung
Bit
Subtraktion
Punkt
Gruppenoperation
n-Tupel
Wahrheitstabelle
Mathematische Logik
Code
Computeranimation
Informationsmodellierung
Vorzeichen <Mathematik>
Prozess <Informatik>
Code
Gruppe <Mathematik>
Fokalpunkt
Skript <Programm>
Vorlesung/Konferenz
Optimierung
Beobachtungsstudie
Soundverarbeitung
Umwandlungsenthalpie
Softwaretest
Parametersystem
Anwendungsspezifischer Prozessor
Güte der Anpassung
Multiplikationssatz
Mailing-Liste
Elektronische Publikation
Quick-Sort
Rechenschieber
Diagramm
Konditionszahl
Mereologie
Gamecontroller
Wort <Informatik>
Refactoring
Instantiierung
Demo <Programm>
Bit
Gewichtete Summe
Adressraum
E-Mail
Code
Fluss <Mathematik>
Demoszene <Programmierung>
Bildschirmmaske
Variable
Informationsmodellierung
Weg <Topologie>
Vorzeichen <Mathematik>
Reelle Zahl
Objektorientierte Programmiersprache
Gruppe <Mathematik>
Delisches Problem
E-Mail
Gerade
Demo <Programm>
Analysis
Shape <Informatik>
Kategorie <Mathematik>
Validität
Einfache Genauigkeit
Variable
Quick-Sort
Objekt <Kategorie>
Druckverlauf
Konditionszahl
Mereologie
Debugging
Bit
Mathematische Logik
Mathematisierung
Gruppenkeim
Geräusch
Code
Überlagerung <Mathematik>
Variable
Datenmanagement
Softwaretest
Arithmetische Folge
Code
Weitverkehrsnetz
Datenstruktur
Gerade
Schreib-Lese-Kopf
Beobachtungsstudie
Softwaretest
Lineares Funktional
Mathematisierung
Quick-Sort
Programmfehler
Gruppenkeim
Flächeninhalt
Debugging
Turtle <Informatik>
Refactoring
Message-Passing
Zeichenkette
Soundverarbeitung
Softwaretest
Lineares Funktional
Güte der Anpassung
Entwurfsmuster
Schlussregel
Domänenspezifische Programmiersprache
Biprodukt
Quick-Sort
Code
Computeranimation
Faktorisierung
Deskriptive Statistik
Linearer Code
Diskrete Simulation
Refactoring
Vorlesung/Konferenz
Projektive Ebene
Wort <Informatik>
Refactoring
Datenstruktur
Videokonferenz
COM

Metadaten

Formale Metadaten

Titel So You Want to Start Refactoring?
Serientitel RailsConf 2015
Teil 32
Anzahl der Teile 94
Autor Foley, Jillian
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/30704
Herausgeber Confreaks, LLC
Erscheinungsjahr 2015
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract New programmers often react with dread when the word "refactoring" starts getting thrown around at standup. Maybe you've seen fellow Rubyists struggle with old code, or a colleague spend days on one module only to end up with exactly zero changes to functionality. What exactly is refactoring, and why would anyone want to do it? What are some tips for approaching a refactor, both generally and in Rails?

Ähnliche Filme

Loading...