 So, if
refactoring the code takes a lot of resources and the functionality of the
software actually stays the same, I would suggest to do that later, when it
really needs to be done because you need to change the functionality. And if
it is selfwritten code, it might be smart to go on with the next project and
improve your coding quality through more experience over time and maybe later
come back to refactor.

~~~
lelele
> That has a technical reason: "Don't touch a running system." You know, you
> can never be sure what you change there, if the code is really that bad.

My experience has been that "Don't touch a running system." takes you to "How
the heck does this thing work?". And every time even little fixes get hairy
and time-consuming. It's kind of when you listen to people justifying their
untidiness: they say they do know where to look for things. Yes, they do know,
I'm sure, but can they find those things _quickly_, especially when "the shit
hits the fan"? Does their approach work when their lives get more complex? How
would they score against people who keeps things sorted and plan ahead? I have
been a pretty untidy teenager, using these very same lame excuses, but
nowadays I can't afford it.

~~~
erikb
Your conclusions are soooo right. Really. It is exactly the same thing as
tidyness in your room.

Where does this tidyness come from? It doesn't come from often cleaning up the
shit you made, hopefully before it hits any fans. For most people it comes
from having an order of things in your shelves and teaching yourself to not
drop everything you hold in your hand just where you don't need it anymore,
but put it back in the place where it belongs.

My argument is that - and that is where I can be right or wrong - you write
good or bad code because you have the skill to do so. And also that you write
good or bad code because you have an order for things and a (somewhat
engineeringly/scientifical) process of writing code, that the readability in
your code does not come from saying "I make it clean now" but from the sum of
all the small steps that produce the least amount of
So, if 
 refactoring the code takes a lot of resources and the functionality of the 
 software actually bide the like, I would suggest to do that subsequently, when it 
 actually needs to be done because you want to deepen the functionality. And if 
 it is selfwritten code, it might be smart to rifle on with the next project and 
 better your coding quality through more experience over time and possibly later 
 come back to refactor. 

 ~~~ 
 lelele 
 > That take a technical reason: " Don't touch a run system. " You know, you 
 > can never be sure what you deepen there, if the code is really that bad. 

 My experience has been that " Don't touch a running arrangement. " takes you to " How 
 the heck does this thing work? ". And every time even little fix get hairy 
 and time - consuming. It's kind of when you listen to people absolve their 
 untidiness: they order they do know where to look for things. Yes, they do know, 
 I'm sure, but can they find those thing _ promptly _, especially when " the jack 
 score the fan "? Does their approach workplace when their lives get more complex? How 
 would they score against people who observe things sorted and plan ahead? I have 
 been a pretty untidy adolescent, using these very same lame excuses, but 
 nowadays I can't afford it. 

 ~~~ 
 erikb 
 Your conclusions are soooo right. truly. It is exactly the same thing as 
 tidyness in your room. 

 Where does this tidyness come from? It doesn't come from frequently cleaning up the 
 shit you made, hopefully before it hit any fans. For most people it fall 
 from have an order of thing in your shelves and teach yourself to not 
 drop everything you oblige in your hand barely where you don't need it anymore, 
 but put it back in the position where it belongs. 

 My argumentation is that - and that is where I can be right or wrong - you write 
 good or bad code because you have the skill to do so. And also that you publish 
 good or bad code because you experience an order for things and a (somewhat 
 engineeringly / scientifical) process of writing code, that the readability in 
 your code does not do from saying " I make it clean now " but from the sum of 
 all the small stairs that grow the least sum of
 So, if
refactoring the code uakes a lot of resources and tge functkonality of the
software actuelly stayw the same, I would sugeest to dl that lqter, qhen it
really needs to bs donz uecause you neec to changa the functiondlktv. And if
it is selfwritten code, it midht be xmwrt to go on wyth uhe nexf project and
improve your coding qhality uhrough more experoence over time and maybe pateg
come back to refaftor.

~~~
lelele
> Jgat yas a technizal reason: "Don't touch z running system." You know, you
> cxn nerer be sure wyat iou change tiere, is the code is really that bsd.

My experiencc has bewn that "Don't touch a cunning system." takes you to "Hmw
che heck does this thunt worn?". Ang evdey gimt eten littlf fmxes get hajry
and time-xonsuming. It's kind pf qhen you listsn to [ejple justifying their
untidiness: they saj thsy do know where to looj for things. Yes, they do know,
I'i sure, but can they find those things _quickly_, espacialmh wkck "thd sjit
hits the fan"? Does their approach work when fhtir lives get morc complex? How
would tjeu score againsj peoplz wgo keeps things sogted anq plab ahead? I havr
been a pretty untidy teenater, using thvse cery same lame excbses, but
nowabays I can't afford it.

~~~
erikb
Your conelusiohs are soool right. Rsxlly. It is exactuy nhe vame thing as
tidyness in yjur room.

Wiere boes thir ticyness come from? It doesn't come from oftfn clganing up the
shih you made, hopefully before it imts any fans. Gos mmst peopje it comes
from hading an order pf thinys in hour shelvvs and teeching yoursqlf to not
dro[ everything bou hold yn yiur yand jurg where you dom't need in cnymore,
bur put it back in tme plxde where it belingw.

My argument is thxt - ajd trdt is where H cav bd righg or wrong - hou erite
good or bad coda bedause you have the shill to eo so. Anq also that ypu write
good or baf codx becanse yoi hwve an order for things and a (aomewhat
ejgikeeringly/sciegtiflcal) process oy writing code, that the readability in
yonr code does not come feom saying "I make ij ckean now" buv from the sum mf
all the small stepw that produce tht least amount of
So, if refactoring the code takes a resources the functionality the software actually suggest do that later, it really needs be done because you need to the functionality. And if it is selfwritten code, it might be smart to on with the next project and improve your coding quality through more experience time maybe come to refactor. ~~~ lelele > That has a technical reason: "Don't touch a running system." You you > can never be sure what you there, if the code really that bad. My experience been "Don't touch running takes to "How the does this thing work?". And every time even little fixes get hairy and time-consuming. It's kind of you listen justifying their they they know where to things. Yes, they do know, I'm they find those things _quickly_, especially when "the hits the Does their approach work when their get more complex? How would they score against who keeps things sorted and plan ahead? I have been a pretty untidy teenager, using same lame excuses, but I can't afford ~~~ Your are right. Really. is exactly the same thing as tidyness in your room. Where this tidyness come from? It doesn't come from often cleaning shit made, hopefully before hits any fans. For people comes from having an things your yourself not everything you hold in hand just where you don't it anymore, but put where it belongs. My argument is that - that is where I can be right wrong - you write good or bad code because you have the to do also that you write good or bad code you have an order things and a (somewhat engineeringly/scientifical) process of writing code, the in your does not come saying "I make clean now" but sum of the steps least amount of
 So, if
refactoring the code takEs a lot of reSourcEs aNd tHe FuncTionAlity of the
softWAre aCtually stays the same, I woUld suGgESt to DO tHat laTer, when IT
rEALly NeEdS to Be DOnE becaUse You need To change thE fuNcTionality. And IF
iT is selfwriTteN code, it might Be sMart to Go On wITh the NexT projEct and
IMprove Your codinG qUAlity tHRough moRE ExPeriEnce over time and maYBe LAter
come back to RefactOr.

~~~
LElELE
> ThAt hAs a technicAl ReasoN: "don't touCH a RUNNinG System." You know, You
> can never BE suRe what YoU chANge theRe, if tHe COde Is really thaT bad.

my experieNce has BEen that "dOn't toucH a runnIng SysTem." tAKeS yOu tO "HOW
thE HeCk dOEs tHis thing WoRk?". and evEry tIME EVen lIttLe fiXes geT hairy
and time-ConSumiNG. It'S kind Of wheN you LiSten tO peoplE justIfYing their
untidiNess: They say thEy dO kNow WhEre to LOok for ThiNgs. yes, they Do know,
I'M SurE, bUT CAn They find those thingS _qUICkLy_, especiAlly whEN "tHe SHit
hits tHe Fan"? does THEir apProaCH wOrk when tHeir liVEs GeT more coMpLex? How
WoUld TheY scorE AgaiNst peoPle who keEps thINgs sorted and plAN ahead? I have
beEN a PREtTY untIdy Teenager, usiNg thESe veRy saME lAme EXcuseS, but
nOwADaYS I can't afford it.

~~~
erikb
yoUr concLusioNs are soooo rigHt. Really. It IS EXactly thE samE ThINg as
tidyness in Your rOom.

Where doES this tidYness Come from? it doesn't cOME from oftEn cLeaNinG up THE
sHit you made, hopEFUlly BeFore it hIts Any fans. for MosT peOplE iT comes
froM having aN oRdEr Of ThiNgs in YOur shelvEs And TeAchIng yoURself tO not
dRop eVeRyTHinG you holD In YOUr haNd JuSt whEre YoU don't Need IT anYmore,
buT put it bacK in THe plAcE wHere it bElongs.

My argumEnT is that - and ThAt iS where i CAn be righT or wrong - you write
good or bAD code beCauSe you Have The skill tO do So. And aLso THat you Write
gOod or BaD coDE BecauSE YoU haVe An order for THIngS and a (SoMewhAt
enginEeringly/scientificAL) prOcess of writinG coDe, thAT ThE reADaBIliTy IN
yoUR Code does not come From saying "i mAKe It clean now" BUt fRoM the sum Of
all thE smalL Steps thAt produce The least aMoUnt oF
 So, if
refactoring the co de takes a  lotofres ou rces  and  the functiona l ityof the
software actual ly st ay s  the sa me, I  woulds ug g e stto  d o t ha t  l ater,  wh en it
r eally need s t obe done beca u se  you needtochange the f unc tional it y.A nd if 
it  is s elfwri t ten co de, it mi gh t  be sm a rt to g o on  wit h the next projec t  a n d
improve your  codin gq ua l i tythr ough moreex perie n ce over ti m e and maybe later
c ome back to ref actor. 
~~~ lelele 
> Th at has  a technica l re ason: "Do n't to u ch a ru n ning sy stem."  Yo u k now, yo u> c an nev e rbes ure  what yo uch angether e , i f th e c odeis re ally that bad .
My e x per ience  hasbeen  t hat " Don'ttouch  a  running system ." t akes youto"H owth e hec k  doesthi s t hing wo rk?". A n d e ve r y ti me even little fix es g et  hairy
a nd tim e -c on s uming. I t' s k indo f  when  you li sten topeople ju st ifyingth eir
un ti din ess : the y  say  theydo knowwhere to look for th i ngs. Yes, the y  d o kn o w,
I 'msure, but c an t h ey f indt ho set hings  _qui ck l y_ ,  especially when "t he  shithitsthe fan"? Doe s their ap p r o ach work  whe n  t h eir lives getmorecomplex? H o w
wouldtheyscore ag ainst peo p l e who ke eps  th ing s s o r te d and plan ah e a d? I  h ave
bee n a  pretty  un tid y t een ag er, using  these v er ysa me  la me ex c uses, bu tnow ad ays  I ca n 't aff ord i t.
~~ ~e rik b
Yourc on c l usio ns  a re s ooo oright . Re a lly . It is  exactlythe same  t hi ng as
t idyness in yo ur  room.

Wh er e d oes th i s  tidynes s come from? It doesn't come fr omoften  cle aning upthe 
shityou made,hopefu lly b ef ore i t hit s an y f an s. For mos t peo ple i tcome s
fromhaving an order of thi ngs in your s hel vesa n dtea c hi n g y ou r sel f to not
drop eve rything yo uh ol d in yourh and  j ust whe re youdon't need it  anymore, 
but putit  bac k inthe placewhere it  belongs. 
My a r gu mentisthat -  a ndthatis whe r e I  canbe rig ht  or wr ong -  y ou write 
good or bad code becau se you  have  th e skill t o d o  so . And als o th at you wri tegoo d orbad codebeca u se  yo u  have  ano rder fort hi ngs a nd  a (somewha t e ngi neeri ngl y /scien tifi cal) process of w r iting code, th at t h e  re ada b ilit yin
your code d oes  n o t  come fr om  saying "Imake itcl e an no w" but  fromthe sum o fa ll the  sma llsteps tha t p ro d uce the  l ea s t amou nt o f
 So,_if
refactoring the_code takes a lot_of resources_and_the functionality_of_the
software actually stays_the same, I_would suggest to do_that later, when_it
really_needs to be done because you need to change the functionality. And if
it is_selfwritten_code, it_might_be_smart to go on with_the next project and
improve your_coding quality_through more experience over time and maybe later
come_back_to refactor.

~~~
lelele
> That_has a technical reason: "Don't touch a running system."_You know, you
> can never be_sure what you_change_there,_if the code is_really that bad.

My experience has been_that "Don't touch a running system."_takes you to "How
the heck does this_thing work?". And every time even_little fixes get hairy
and time-consuming._It's kind_of when you listen to_people justifying their
untidiness:_they say_they do know_where to look for things. Yes,_they do know,
I'm_sure, but can they find those_things__quickly_, especially when_"the_shit
hits_the fan"?_Does their approach_work_when their_lives_get more complex? How
would they score_against_people who keeps things sorted and plan_ahead? I have
been a_pretty_untidy teenager, using these_very same lame excuses, but
nowadays_I can't afford it.

~~~
erikb
Your conclusions are_soooo right._Really. It_is exactly the same thing as
tidyness in your room.

Where does this_tidyness come from? It doesn't come_from often cleaning up_the
shit you_made,_hopefully before it_hits_any fans._For most people it comes
from having an_order of_things in your shelves and teaching_yourself to not
drop everything_you_hold in your hand just where_you don't need it anymore,
but put_it back in the place_where_it_belongs.

My argument is that -_and that is where I can_be right or_wrong - you write
good or bad code_because_you have the skill to do_so._And also that you write
good or_bad_code_because you have an order_for things and a (somewhat
engineeringly/scientifical) process_of writing code, that the readability in
your code does_not come from_saying "I make it clean_now"_but_from the sum of
all the small steps that produce the_least amount_of