Merken

An Optimistic Proposal for Making Horrible Code... Bearable

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
the V and here and be I am welcome name is John necessary to talk about horrible terrible no good good bases I'm going to quit Cheyenne's who here is doing currently would just horrifying code and work Mac OS is is pretty much a support group that not announced and so I worked a lot different companies over the course my career and this is really been 1 of the common threads across all the companies I work at I guess I'm fortunate enough to workplace there a profitable have but the result of that is the usual places have just terrifyingly bag and so we'll talk
about a lot of things I wanted start off I'll give you an example of a code base I'm working with this and use it as an example across the entire talk and this is some of the cells working out when real 4 . 1 was being released by the kobe working with with rails 1 . 2 were actually super proud of being a real 1 . 2 2 lectures started 0 . 7 and managed awake away all the way up to 1 . 2 fantastic a lot of characteristics that you know you're probably thinking about free round-trip kobe
since we had custom packages so he decided the nation right around with SSL changes which meant that we were running around the crests uh system libraries in pretty nasty stuff that we had 6 thousand line usable yeah fantastic good news is that everything is in 1 place the bad news is that everything than 1 to on the test we took 4 days to run on a laptop but I will little misleading because of course is that it takes for is run test suite you don't run your test we have a laptop and so we we actually paid you know 5 figures were the aid of US bills it to run across hundreds of machines we got down to 4 5 hours before its unit test and when it did pass is about 10 % the test plot 0 no flap intestines myself some people do isoflavones does basely any test where it passes sometimes but not all the time so white 50 per cent of time it's green 30 % of our screen words unless it's like a Friday at the end of the month a and so every time you get to test from that you have you know so between 150 and 300 failing tests but it's not really certain which just it we have a million lines remittances from a more accurate to say this wasn't a Rails out this was a really ecosystem with the rails at hiding somewhere inside right and so we
slide transition to so we did exactly what you do in a situation and right we we declare the entire legacy code base as deprecated we off 30 % of our team and then build a brand new copy the codebase decided a year from now we would completely tear down the old code base to be done by can be rails forest in the you know Micah services opossum and 1
exactly the way you expect go right back the that successful rewrite is the show and they actually deprecated the general Gomez before as 1 and 2 and this nice but so again have OAU you expects 18 months later we had the new code base which we managed to about 10 per cent of revenue on to it so we can kill it because now is actually making money and the monster they continue to make all right of course everybody really wanted to work on the new code base you can't blame
them right nucleobases where all the more interesting code happens you know things it took us 2 weeks to do O'Neill codebase we can do understand holidays a new code base the challenges of course that we have to continue running the business our requirements are still changing you can actually freezer or in humorous attempted deprecated the entire that ran keep updating this is a big challenge right and I became really interested in this topic because this to ourselves at some point something went into a class file and 5 thousand 990 lines of Peruvian and a set of the right thing to do was add 10 more lines of verbal right and then you know better you know that you don't need to have 200 methods in 1 class you know that that's not the right thing to do and we made that decision anyway aligned understand why because I mean 1st of all because we're about to build a 2nd monster and because the and this this to me is like such a common thing that I don't really understand how people who have all the skills who have you know you go through refactoring courses by news on this and yet you make is really bad decisions you keep adding particles
upon particles and so you are completely untenable and so is working with a budget over them as database basis and down and so that's when you know why is it that we don't it's without political and I have responses like this get codes in use anymore
right into any of 2 other methods you go into an object you delete a of the code we look at our water that's still being used of course it's practically impossible and we have some super nasty um the method missing magic that we use all the place so we just learned Ruby and really early days of a code base like man I have the link to clear anything it's just all never missing this badge that way and so is is impossible to tell what's going on around the James encode breaks completely unrelated tests a story of 1 time I had so the change of you and break the unit test I do not know how that works and yet theory or what it like merging your style poles hopefully you guys there are of the belief that it's useful to have a somewhat consisting of style so if you do it we did you know install rule copyright Rook up against a codebase need this job
you need you know you can do is it there's a dash ARG can auto fix solid years style violations here and you just put up a pork was that has 69 thousand changes and and
we can trust investment but but I mention takes run a lot of failures no cost any time you change is a code a bunch of new test of breaking we don't know about actions functionality is broken as a start to shy away from us right we're not an old wait days to run my tests so you know instead we became surgical when our precision we learned how to not disturb any of the code around what we were trying to change make the tiniest possible change listen up government as then run like hell the 1 is my name is not only get blamed we are OK I a couple times there we we try and you know figure will fix itself and you know whatever new libraries will splitting up but I
always felt like she you know basic genome book out the entire ocean is low-pass advice for you keep going keep going and you never make income of us all as early as this here
over time we became afraid of changing the code is an actual psychological condition an interesting side note it's also when the underlying conditions to clinical depression fossils but and we just we became afraid of making changes in so now not only do we have the original problem of a code base continues get worse when the secondary problem of not being willing to change here the trough of despair so pretty
nasty situation right when is is that once we actually took the time to you know take a look take an honest look at why we continue to make everything worse you know the opportunity to stop at right so when they talk about how
to tackle these 2 problems for lessons on number 1 how you become less afraid of the codebase number 2 action dismantle in a way that is saying at 1st bowler we have assumed name the before this is all constant like knowing of things true name is to have power over right it's cool concept I think this is actually true about when we deal with are really problematic chunks of code vastly to think about this really a tough terrible base that you have that 2 dealt with which usually think of is the very worst affected right at whole slide it's a million lines of code and see how 6 thousand lines of the sentence you tested that takes forever and becomes a standard and in your mind for everything about that every time you try to deal with that what you get is the image of this being impossible things but a terrible cognitive TREC right as not the reality every code base of seeing the badness is unevenly distributed what I mean by that is they're usually those couple things that you would put on the slide and those are the ones are horrible everything else can trails of to example are you looking at us something when you and if you don't do love
base's my what kind weird you don't project for this but take from the inside out if you look inside the parentheses we can you find me with the name of start our basis finds read files pass it to Debussy dash that is the word count and dash elderly the lines our so funny lines in every file in your system and take it to sort of world this something that I I do pretty frequently actually what I'm looking at big chunks people say well our our service objects about our tests are bad else say OK we're going to test so will just run this command on your test I would find is this kind of the output that is the number of lines sorted my spectral I want colony 1 particular so in the summer devise code-based can otherwise not so bad but the characteristics of this I think a really interesting this follows a pattern of C most people's bases the very bottom file has 700 ones not great not terrible that's fine but only takes like 4 5 files before itself is half the size and most everything in our code base is much much much smaller and so I think is that the bad
news is really a and it's an exponential distribution right so at the very far left we have a couple files that our infinitely terrible as we move to the right we get is this you know the long tail of things that are users can OK that's a really useful realization as far as I'm concerned because that means that we can just come off a couple things and watch movie really hard on 1 the way we can quantify some bad things
they use rate that's before only a couple so this engine built into your Rails up already you have rails This is the command you can run right now and what it does is just run through all your files and give you an output like this new ended a relatively small conveys for illustration as a lot happening here uh but just to give you a sense of something that can be useful to us but so this town will give you the lines of code in every section of your application an absolute numbers don't really matter here because you already know that you have a billion lines of horrible codon you're really not going to read all the review but it does tell you can wear tied In this case there's not much happening in mailers in there's a ton having control so it was very controller had the application and to insert to quantify what's going on and over here the last 2 columns no 1 left is number methods for controller model right is the number of lines and can be a lines of code from again we can start to get his real metrics the accurate so we can qualify what's going wrong so we can see that yes we know that our methods are too long the reality is that that's really only true inside of 4 models it's not in leadership the and in our
case there are a lot of a metric so we wanna get once we got the inference that we could you know start quantifying these things we realize that normal output of the tools were looking at wasn't very helpful and so we wrote somewhere else so many things
I will make a quick method is number of methods for Active Record class this symphonic you know you can do this you can actually look at all classes that exist on the 1st line select for the ones the children of active Record been sort them but a number methods so class methods that count recipients or more a mapping and some string so it's not great code not the kind of thing that I put up on a pedestal but actually gives you this really interesting view of what's happening in your system and once again we see that the models of the very top had a lot more going on the models of the bottom and it's distributed the same Conway
this is another thing I created my hand in principle like code bases of my uh test were slow because I was creating tons and tons of Active Record models are notes it's that it's a blinding realization that is exactly what people tell you but it's not really good enough to just say ah Tessa bad because there are a lot small you know laughter models being created the reality is that you use don't know which ones are creating a lot of records and so I built a simple formatter for our spec what it does is when rerun run your tests and I can see in the green there to the left it shows you how many models are created and how many queries were run it takes an uncertain bad a new view of the sensor measurements the sensor precision and when you do this when you add these sort of things your codebase what you find is that the sort of overwhelming terror on fixing these codebases as a becoming green manageable there are a couple places horrible the couple Tessa or but
associated to do is talk about how we actually approach fixing some right you the 1st thing stop the bleeding we got where we are precisely because we kept making things incrementally worse we cannot fix everything we start making the code worse this difficult to enforce that line by just saying please don't make everything that use of course you know people or you're in a position where obvious thing to do a RoboCup remember Dennis near 70 thousand style violations but
there's another way we can run it if you run rule
cop against a codebase find the very largest file and then set the threshold to add files numbers so what I mean is run woke and says well you got you know 23 parameters on this method is a great this is our new threshold we will never be worse than 23 parameters on that means of again very courageous statements right any go through you do this for all the major metrics and the goal here is to have a green rule out or and I just have a fake green right like on and you know no worse than 6 thousand 275 1 the code but the usefulness of that green is something that you shouldn't take for granted because then any time something goes back in the class and adds more code we get 1 might they get an actionable violation and every time you're able to go in and start cutting apart the very worst partieiple basis so well we have this method as 23 parameters of taken down to 22 great victory we also tighten up our parameter in the configuration useful
ratcheting was 1 of my very favorite techniques for starting get a handle on these chemical bases because they only move 1 way at the very least do not get any worse and as you get better you find is incredibly satisfying tubulin tightening down those ratchets now in a situation where I was dealing with this there was some metrics that remote Cobden had at the time I think some of our actually handled now but there is another way that you can do this to be no 1 knew it through a up is also useful if you were engineers in your team don't really care very much about style violations of another kind of folks or a run on the test
so this is the coda we had before remember objects we put in some aspect change subthreshold military chose classes a crater describe block now this is kind of the devious are that is not something I would encourage you to do in any other situation was actually integrate these expectations and and and what that gets reuse that now every time they violate rule is actually end up failing a test this is a lot easier to catch encode reviewed a lot easier to to catch overall is 1 specific set of tests that you can look at and know that these are not the kind of test that would normally come up right that so stubborn
and then the Jackson 18 per the important part right skills they were on the forward helping us very much of what in some ways we can actually go down to some smaller we can we can actually enact successfully so 1st rule before you know
actual result think globally but act locally or I mean by that is that if your goal is to make sure that all methods have no more than 10 lines you will not go do that your entire of there will never be that all requests it's not that and so you should keep their goal in mind you have to become comfortable with the notion of fixing these things a small amount of time 1 other ways that you fix Banco bases is typically to introduce new patterns you decorators and service objects in such and you know yesterday just URLs is talking about the value of having consistent style and cross your entire code and what he said was that you know if you don't have a consistent value pay penalties and is interesting because 1 encouraging you to do here is specifically to have different patterns in your code where in transition but the reality is that when you're dealing with not really feel codon not a new development you're working on this monster you have to accept that downside In order to make any progress the pursuit of like consistency is destructive which you break it is going to happen if you are a senior developer do the junior developers a favor and fuck up every once a while it a scary right like the 1st time take down production the person make a change that's as truly frightening moments and do all make mistakes like but I sure we're phrases not you should make mistakes but that you should be honest about the fact made mistakes we are all screwed up consistently would be honest enough about it that everyone else doesn't perceive you as never make a mistake states I remember that as we fix things we're going to break the that's reality your estimate it but particularly compared to prioritize
the are of things I think you should fix the the shoemaker tests OK usually a dynamic code to be and dragon by which I mean you should kill those really bad pieces of code we should prioritize high churn what you those so
tests the ashes some really cool blog articles on how you can look at you know you're clapping test I look at a slow tests and go in and fix each 1 and I had a lot of the people inside teams say all assigned might to you raise an look at every single flapping test and the more slowly and moved on 7 will be stable it is never ever worked I have never seen this work as I have a much better strategy for you to get your test back to being great data I mean don't know the and the reason I mean this is that bad tests a bad test suite is worse than useless you still pay the entire cost to maintain sweet you pay the cost of writing a tests you pay the cost the literal dollar cost of running and parameter mu us across 100 instances but at the end of the process it doesn't tell you whether suffer works and I don't care if you a hundred per cent coverage if the output of it is useless you be better to reduce your coverage having Green Run then to attempt to keep working your way back to that's stability isn't Evergreen you have a real signal something goes red you have to fix it you will I get to that place incremental which migraine new test facts so all the techniques that we know about refactoring depend on the ability to run tests right and especially if you've taken my advice and the Weighted sum test you could be writing some new test as doesn't work if you need to spend an hour running in these industries now they the realistic version of this is that you
should really endeavor to write tests that are not coupled to the rails for you know again there is a little bit of what Justin was talking about yesterday was i.e. writes his classes that do not need to interface of Active Record directed awakened do that these tested 10 times faster at least and I like to avoid those worst part too much new Hey 2nd
angling dynamic code so I'm alone others because Ruby is like were really cool in the program like will really hidden that apart you can do anything as long as the features that everybody loves minus 8 you're allowed to do it because you're
like a teenager the credit card the max out you light looking to score again you can the some people who are allowed and dynamic code once you're in trouble with your codebase you privileges are about but if you need to find a place in your code base for your work using this dynamic code and remove them so for example this
is a pattern I see a lot of the very 1st line we ground something that is probably a string constant eyes and instantiated is a promise if I ever wish to delete any code ever I have to make sure that is no longer in use this is impossible in through code base for a more they have a scanner magical worse off you are is another version of it going states and doing send it somewhere probably no methods actually defined for these work as things but again it's impossible to know where they're being used if you
really evil they just you would call him out and you see the coding here inside the class declaration apparently you can write actual code snippets inside of your class but not not the block of the class but where the name would go you can put a statement curdle tha
so I generally use any of these methods consider getting rid of as much fun as it is to be dynamic and Allianz and all that it's not as important as being an understanding of its what you end up with is this sort of thing and anybody who knows me knows that I aboard case statements I want to bring them all fire and yet this is better than not being able to figure out where your code is in use is very understandable 1 elegant next and have so what
I mean by this is that bias and we have this distribution where there are only a few things that are really really terrible and I think that you should spend time specifically dismantling those things course 6 thousand line uses as is actually runs against the advice that you get from a lot of people who teach refactoring the rule is usually that you should only factor something that has a new constraint you need to fix a and again that's really good advice because normally you're your undertaking some risk in some pain and you don't wanna do that for no reason we overriding reason here is again that those singular pieces of terror make people afraid to work address the code that's if we can cut them apart are distribution looks like next it's back the so this looks like specifically for your code codebase is really individual cover every possible type refactorings and it's not that kind of talk but 1 thing I wanna get across to you is that when I say to get rid of these files to make them less bad I'm not saying to go into your 6 thousand line user file and refactor every line of it because once again we do not have the ability to make that any changes you will not refactor 200 different methods what you can do is them apart so the is as example you're control so controller say it's got you know 50 rounds define underneath it it's really really difficult for us to go through all those routs make us a sensible change right or we can do is define a new class
initialize it with some parameters and then take the 200 lines of misery and is plotted in a corner you can use run it it'll failed to fine whatever helper methods you need to pull into it and European process you would be able to create a single chunk of code for this action beyond or controller this is the 1st 2 of this method all they do is that service invoked . call on and pull some instance variables back out now when you do this you're basically instead of having 1 controller the has 3 thousand lines of code you have 10 classes with 300 lines of code and you'll still have some somewhat control of over again explicitly you will have more code than when you started In the same that's done would you have something
in trade for that's what you get is that when you're working with any individual 1 of those services you only need to think about what's happening inside of that service that is incredible improvements in your ability to make changes you don't have to execute the controller itself in order to test the service as a huge improved the and you no longer have that 1 spot where humans you know don't dare to tread interest expense as a huge improvement last assignment German and who doesn't know churners so under this metric before goal so churn is the notion that there are parts of your code which change a lot and their parts your code that don't change a lot so we will word for that idea and a couple things if fall this the the 1 idea is that if your code is churning probably 1 of 2 things to about either the requirements change a lot where your code is bad probably both in reality this is another thing we can take out the top purposes which is that any kind of bad that you have to deal with get worse when you have to deal with on a daily basis to keep changing and so once you get rid of the very worst part to the you left with now you know large well of next some horrible library as an excitation prioritize is that code the terms you know we can't go through and fix our 70
thousand offences but I can go through and fix 1 of our and for this is a sensitive a boy scout policy you know what are you going to a file we clearly about this is something we can actually start to handle as as an individual what
so they evil stop the bleeding and strategically improve at so strategy and he did this things will be better the universal and so on the challenges that we face so the Forest Focus on process however the Sun it means talk yesterday is talking about really focusing on a long term goal 3rd digit is keen on the 1st date time by having that's important in this case I should say from digit is I don't think you are a Sisyphus I should have access slide nearly use that a white that seem like a really weird specific thing repeat between 2 toxins cited out but I don't think you are because in the legend Sisyphus he made no progress I mean they're all the rock up the hill and you may roll back down the reality is that you can make things better so and so what you have to do is takes a lot of cells and good things that do happen when you have these victories celebrate them because when things are going as well yeah well it back on them so the 1 other thing when you nouns dramatically in the dark right this is always been a really interesting idea to me on the top you have to make is 1 per cent worse every day for a year in the year young monster who tiny change make things 1 per cent better instead such a big change but in media you have something incredible something really interesting me about this I think you have the opportunity to be the latter most as such I think you should it's all that my slides are up on a while this bitterly link all posting on Twitter as well and please feel free to follow me on Twitter and the gonna ask any questions like you thank this happened
arms so
Resultante
Subtraktion
Code
Gruppenkeim
Stützpunkt <Mathematik>
Thread
Code
Computeranimation
Softwaretest
Suite <Programmpaket>
Komponententest
Benutzerfreundlichkeit
Mathematisierung
Güte der Anpassung
Datenmodell
Zellularer Automat
Plot <Graphische Darstellung>
Code
Computeranimation
Physikalisches System
Virtuelle Maschine
Softwaretest
Suite <Programmpaket>
Rechter Winkel
Notebook-Computer
Programmbibliothek
Wort <Informatik>
Charakteristisches Polynom
Figurierte Zahl
Gerade
Touchscreen
Monster-Gruppe
Rechenschieber
Physikalisches System
Dienst <Informatik>
Softwaretest
Wald <Graphentheorie>
Suite <Programmpaket>
Rechter Winkel
Gruppenoperation
Datenmodell
Ganze Funktion
Code
Computeranimation
Punkt
Datenhaltung
Klasse <Mathematik>
Systemplattform
Elektronische Publikation
Code
Computeranimation
Entscheidungstheorie
Menge
Rechter Winkel
Basisvektor
Endogene Variable
Partikelsystem
Gerade
Softwaretest
Stereometrie
Komponententest
Wasserdampftafel
Mathematisierung
Schlussregel
Binder <Informatik>
Physikalische Theorie
Code
Computeranimation
Objekt <Kategorie>
Polstelle
Softwaretest
Prozess <Informatik>
Code
Kontrollstruktur
Installation <Informatik>
Metropolitan area network
Softwaretest
Lineares Funktional
Suite <Programmpaket>
Gruppenoperation
Heegaard-Zerlegung
Mathematisierung
Programmbibliothek
Figurierte Zahl
Code
Computeranimation
Konditionszahl
Mathematisierung
Code
Computeranimation
Desintegration <Mathematik>
Zahlenbereich
Zählen
Punktspektrum
Code
Computeranimation
Eins
Distributionenraum
Total <Mathematik>
Mustersprache
Stützpunkt <Mathematik>
Gerade
Bildgebendes Verfahren
Leistung <Physik>
Funktion <Mathematik>
Softwaretest
Elektronische Publikation
Elektronische Publikation
Quick-Sort
Rechenschieber
Objekt <Kategorie>
Dienst <Informatik>
Informationsverarbeitung
Rechter Winkel
Basisvektor
Projektive Ebene
Wort <Informatik>
Charakteristisches Polynom
Faserbündel
Exponentialverteilung
Elektronische Publikation
Linienelement
Applet
Zahlenbereich
Kartesische Koordinaten
Bitrate
Sichtenkonzept
Code
Computeranimation
Informationsmodellierung
Softwaretest
Rechter Winkel
Code
Gamecontroller
Zahlenbereich
Statistische Analyse
Gamecontroller
Skript <Programm>
Garbentheorie
Modelltheorie
Steuerwerk
Gerade
Funktion <Mathematik>
Sichtenkonzept
Inferenz <Künstliche Intelligenz>
Reverse Engineering
Klasse <Mathematik>
Zahlenbereich
Physikalisches System
Quick-Sort
Code
Computeranimation
Eins
Mapping <Computergraphik>
Datensatz
Informationsmodellierung
Gruppenkeim
Trennschärfe <Statistik>
Minimum
Pay-TV
Biprodukt
Ordnung <Mathematik>
Funktion <Mathematik>
Zeichenkette
Softwaretest
Konfiguration <Informatik>
Sichtenkonzept
Ortsoperator
Abfrage
Code
Quick-Sort
Computeranimation
Datenhaltung
Eins
Datensatz
Informationsmodellierung
Datensatz
Suite <Programmpaket>
Rechter Winkel
Endlicher Graph
Stützpunkt <Mathematik>
Gerade
Einflussgröße
Parametersystem
Befehl <Informatik>
Schwellwertverfahren
Linienelement
Linienelement
Basisvektor
Klasse <Mathematik>
Zahlenbereich
Schlussregel
Elektronische Publikation
Code
Computeranimation
Objekt <Kategorie>
Umwandlungsenthalpie
Softwaretest
Menge
Linienelement
Mathematisierung
Klasse <Mathematik>
Schlussregel
p-Block
Ratsche <Physik>
Code
Computeranimation
Resultante
Schätzwert
Mathematisierung
Gruppenoperation
Schlussregel
Biprodukt
Code
Computeranimation
Monster-Gruppe
Objekt <Kategorie>
Dienst <Informatik>
Arithmetische Folge
Rechter Winkel
Mustersprache
Mereologie
Stützpunkt <Mathematik>
URL
Ordnung <Mathematik>
Softwareentwickler
Ganze Funktion
Gerade
Widerspruchsfreiheit
Softwaretest
Suite <Programmpaket>
Parametersystem
Stabilitätstheorie <Logik>
Prozess <Physik>
Web log
Green-Funktion
Gewichtung
Versionsverwaltung
Code
Computeranimation
Softwaretest
Reelle Zahl
Code
Strategisches Spiel
Funktion <Mathematik>
Softwaretest
Datensatz
Bit
Klasse <Mathematik>
Mereologie
Optimierung
Code
Computeranimation
Konstante
EINKAUF <Programm>
Extrempunkt
Mustersprache
Versionsverwaltung
Gerade
Code
Computeranimation
Strategisches Spiel
Zeichenkette
Aggregatzustand
Chipkarte
Befehl <Informatik>
Code
Deklarative Programmiersprache
Klasse <Mathematik>
Schreiben <Datenverarbeitung>
p-Block
Quick-Sort
Code
Computeranimation
Strategisches Spiel
Nebenbedingung
Distributionstheorie
Prozess <Physik>
Mathematisierung
Klasse <Mathematik>
Adressraum
Gruppenoperation
Unrundheit
Code
Computeranimation
Überlagerung <Mathematik>
Message-Passing
Variable
Datentyp
Gerade
Parametersystem
Fehlermeldung
Elektronische Publikation
Volumenvisualisierung
Einfache Genauigkeit
Routing
Schlussregel
Elektronische Publikation
Singularität <Mathematik>
Dienst <Informatik>
Token-Ring
Rechter Winkel
Zahlenbereich
Gamecontroller
Refactoring
Instantiierung
Dienst <Informatik>
Basisvektor
Mereologie
Mathematisierung
Gamecontroller
Programmbibliothek
Wort <Informatik>
Elektronische Publikation
Ordnung <Mathematik>
Term
Code
Computeranimation
Objekt <Kategorie>
Programm
Umwandlungsenthalpie
Prozess <Physik>
Prozess <Informatik>
Elektronischer Programmführer
Mathematisierung
Güte der Anpassung
Zellularer Automat
Dienst <Informatik>
Binder <Informatik>
Term
Hill-Differentialgleichung
Computeranimation
Rechenschieber
Monster-Gruppe
Twitter <Softwareplattform>
Arithmetische Folge
COM
Rechter Winkel
Digitalisierer
Fokalpunkt
Hypermedia
Strategisches Spiel

Metadaten

Formale Metadaten

Titel An Optimistic Proposal for Making Horrible Code... Bearable
Serientitel RailsConf 2017
Teil 14
Anzahl der Teile 86
Autor Mastey, Joe
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/31476
Herausgeber Confreaks, LLC
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract The attempted rewrite is over, the dust has settled, and the monolith isn’t going away. After all, it’s still the app that makes all the money. On the other hand, nobody wants to work on it, every new feature takes forever, and your entire team is afraid of making any change for fear of the whole thing collapsing in on itself. In this session, we’ll walk through some of the technical and social problems that arise from difficult codebases. We’ll learn to stop making things worse, to measure what we need to change, and start making progress. In the thousand mile journey, here are the first steps.

Ähnliche Filme

Loading...