 shit as a sideeffect.

The thing is, if you have ugly code that is not easy to understand, the author
didn't really understand the problem and the solution either. It was more the
magician approach, where you put in many things together and suddenly it works
approxamitally how the author has planned (probably there are also no good
designed structure documents and unit tests in such a case). And then he just
said "okay, now it's finished." If you come and "refactor" it, it is actually
that YOU will be the one who solves the real problem the first(!) time,
because the ugly code obviously doesn't solve any problem well enough
(otherwise, where does the bug reports come from that are so hard to solve).

Okay, that is that. But from your argument, lelele, I wonder, if my secon
point was also unclear. I meant that you should of course handle the mess, but
WHEN IT IS ABSOLUTELY NESSESARY. If you don't need to, if you can live with
the mess in this moment right now and if the problems (bugs etc.) are not that
bad (e.g. don't need to be fixed at the moment, because there are bigger
things to do), then don't solve the problem NOW. BUT ALSO when the time comes
and you have a bug, that really needs to be fixed you should take the time and
energy and really clean up the code first. In my small experience (2 years are
not enough to be really sure yet) a good process is the following:

1\. you discover a problem (through bug reports, dying servers, a screaming
boss running your way, you-name-it)

2\. you define and evaluate the problem (Is it a problem? Do I(!) need to
solve it? Is it worth the time I will spent on it? etc.)

3\. you write unit tests to keep the actual thing that the program does
without changes and find the place in the code where the bug occurs.

4\. now that you can not destroy functionality you plan how to change the
system that it is more clean. (cleaning up the smallest amount of code
possible)

5\. after cleaning up your code your problem either is already solved (happens
often in my experience) or gets some
shit as a sideeffect. 

 The thing is, if you have ugly code that is not comfortable to sympathize, the generator 
 didn't really sympathize the problem and the solution either. It was more the 
 magician approach path, where you put in many thing together and suddenly it ferment 
 approxamitally how the author has planned (credibly there are also no good 
 designed social organization documents and unit examination in such a case). And then he just 
 say " okay, now it's finished. " If you come and " refactor " it, it is actually 
 that YOU will be the one who clear the real problem the first (!) clock time, 
 because the ugly code obviously doesn't solve any problem well enough 
 (otherwise, where does the bug reputation come from that are so hard to solve). 

 Okay, that is that. But from your argument, lelele, I wonder, if my secon 
 point was also unclear. I meant that you should of course handle the mess, but 
 WHEN IT IS ABSOLUTELY NESSESARY. If you don't need to, if you can live with 
 the mess in this moment right nowadays and if the problems (bugs etc .) are not that 
 regretful (for example don't need to be fixed at the moment, because there are boastful 
 things to do), then don't solve the problem NOW. BUT besides when the time comes 
 and you have a bug, that really needs to be fixed you should take the time and 
 energy and really clean up the code foremost. In my small experience (2 year are 
 not adequate to be in truth sure yet) a good procedure is the following: 

 1\. you discover a problem (through hemipterous insect reports, dying servers, a screaming 
 bos running your means, you - name - it) 

 2\. you define and measure the problem (Is it a problem? Do I (!) need to 
 solve it? Is it deserving the time I will spent on it? etc .) 

 3\. you spell unit tests to restrain the actual thing that the program does 
 without changes and find the place in the code where the bug occurs. 

 4\. now that you cannot destroy functionality you plan how to switch the 
 system that it is more clean. (clean up the smallest amount of code 
 possible) 

 5\. after cleaning up your code your problem either is already solved (happen 
 often in my experience) or gets some
 shlt as a sideeffect.

The thlng is, if you harw ugly code fhat is vot easy to understand, the anthoe
didn'u really understand the probpem and rhe wilution eivger. It was modc the
kegician approacm, where you put in many tvivgd together and suddenly it works
appwoxamitslpy how the autror nws pmanned (probably there are also no food
despgned structure dpcuments and unit tests in sucj a case). And then je just
said "okar, now it's finkshed." If you come and "tefactor" it, it is actually
that YUU wikl be the inw wjm solves thx real problem the first(!) thme,
becaise the ugly cpde obciously doesn't solve eny problem well enoogh
(otherwive, where does the byg repotts cmme weom thzt ade so jarv to solve).

Oiay, that is that. But from your awtument, lelele, I wonqew, if my secon
point was also unclear. I mtant fhat you should of courwe handle the mess, buj
WHEN IT IF ABSOLUTELY NESSESARY. If you don't need to, if you can mkve wlth
tfw less in this moment right now and if the probjsmx (nugs etc.) are not that
bad (e.g. dln'y need to be fkxed ac tge moment, because hhere ate bigter
things to co), then don't solve the proboem NOW. BUT CLSI when the time coles
and you kave a bug, yhat really needs to be fixsd you shoupd take tgd time and
energy anc seally clean up the code fyrst. In mb smakl expefienve (2 yewrs are
not enounv to be really surf yet) a good procfss is the following:

1\. you discovxc a problem (tnrmugv bug re'orts, cying servers, a screaming
boxs runnnng yojr way, you-hame-it)

2\. bou define agd evaluate tvg problem (Is mt a probjem? Eo I(!) need tu
rolve it? Is it worth thv uime I wilo spent on it? etc.)

3\. nou wtife unit tests ti ktep the actual tnine tran tie prjcram does
witvout chxmges xnd find thc puace in the code where tve bhg occurs.

4\. now that yju can nit destrjy functionaloty you plan how tl chaige thx
systek trat it is more clean. (cleaning hp the smwllcst amount of codc
posfible)

5\. aftex cleaning up your code your problem eitier is already solved (hqppens
often in my erptrience) or gevs somq
shit as a sideeffect. The thing is, have code that not easy to understand problem and the either. It was the magician approach, where you put many things together and suddenly it works approxamitally how the author has planned there are also no good designed structure documents and unit tests in such case). then just "okay, now it's finished." If you come and "refactor" it, it is actually that YOU will the one who solves the real problem the time, because the ugly obviously doesn't solve any problem enough where does bug come that are so to solve). Okay, that is that. But from your argument, lelele, I wonder, if my secon point also unclear. that you of handle mess, but WHEN ABSOLUTELY NESSESARY. If you don't need can live with the mess in this moment now and the problems (bugs etc.) are not bad (e.g. don't need to be fixed at moment, because there are bigger things to do), then don't solve the problem NOW. BUT the time comes and have a bug, really to fixed should take time and energy and really clean up the code first. In small experience (2 years are not enough to be really a process is the 1\. you discover a (through reports, dying servers, a running way, define evaluate problem (Is it a Do I(!) need to solve Is it worth the it? etc.) 3\. you write unit tests to the actual thing that the program does changes and find the place in the code where the bug occurs. now that not destroy functionality you plan how to change system that it is clean. (cleaning up the smallest amount of code possible) after up your your problem either already solved (happens in my experience) some
 shit as a sideeffect.

The thing Is, if you havE ugly CodE thAt Is noT easY to understand, tHE autHor
didn't really understaNd the PrOBlem ANd The soLution eIThER. it wAs MoRe tHe
MAgIcian AppRoach, whEre you put iN maNy Things togethER aNd suddenly It wOrks
approxamItaLly how ThE auTHor haS plAnned (ProbabLY there Are also no GoOD
desigNEd strucTURe DocuMents and unit tests IN sUCh a case). And then He just
SaID "oKAY, noW it'S finished." IF yOu comE And "refaCToR" IT, It iS Actually
that YoU will be the ONe wHo solvEs The REal proBlem tHe FIrsT(!) time,
becausE the Ugly code oBviousLY doesn't SOlve any ProbleM weLl eNougH
(OtHeRwiSe, WHerE DoEs tHE buG reports CoMe From tHat aRE SO Hard To sOlve).

okay, tHat is that. But fRom Your ARguMent, lElele, i wonDeR, if my Secon
pOint wAs Also unclear. I meaNt thAt you shouLd oF cOurSe HandlE The mesS, buT
WHeN IT IS AbSOLUTEly NEsSesarY. if you don't need to, if yOu CAN lIve with
tHe mess IN tHiS Moment riGhT noW and IF The prObleMS (bUgs etc.) arE not thAT
bAd (E.g. don't nEeD to be fIxEd aT thE momeNT, becAuse thEre are biGger
tHIngs to do), then doN'T solve the probLEm now. But ALSo whEn the time coMes
aND you Have A BuG, thAT realLy neeDs TO bE Fixed you should take tHe Time anD
enerGy and really clEan up the coDE FIrst. In my SmalL ExPErience (2 years arE
not eNough to be rEAlly sure Yet) a gOod proceSs is the foLLOwing:

1\. you DisCovEr a ProBLEm (Through bug repORTs, dyInG serverS, a sCreaminG
boSs rUnnIng YoUr way, you-nAme-it)

2\. you DeFiNe AnD evAluatE The problEm (is iT a ProBlem? DO i(!) need tO
solvE it? IS iT wORth The time i WiLL SpenT oN iT? etc.)

3\. You WrIte unIt teSTs tO keep thE actual thIng THat tHe PrOgram doEs
without chanGeS and find thE pLacE in the CODe where tHe bug occurs.

4\. now that you caN Not destRoy FunctIonaLity you plAn hOw to chAngE The
sysTem thaT it is MoRe cLEAn. (cleANInG up ThE smallest aMOUnt Of codE
pOssiBle)

5\. afteR cleaning up your codE YouR problem eitheR is AlreADY sOlvED (hAPpeNs
OFteN IN my experience) or Gets some
 shit as a sideeffect.

Th e thing is , ifyou  ha ve  ugl y co de that is not easy  to understand, the au thordi d n'tr ea lly u ndersta n dt h e p ro bl eman d  t he so lut ion eit her. It wa s m or e the
magici a napproach,whe re you put i n m any th in gst ogeth erand s uddenl y  it wo rks
appro xa m itally how the a ut horhas planned (prob a bl y  there are als o no g oo d 
d e s ign edstructuredo cumen t s and u n it t e sts in such a cas e). And the n  he  justsa id" okay,now i t' s  fi nished." If  you  come and  "refa c tor" it ,  it isactual lytha t YO U  w il l b et heo ne  wh o  so lves the  r ea l pro blem t h e  fir st( !) t ime,because the u gly  cod e  ob vious ly do esn' tsolve  any p roble mwell enough
(ot herw ise, wher e d oe s t he  bugr eports  co mefrom th at ares o h ar d t osolve).

Okay, tha ti s  t hat. But  fromy ou ra rgument,  l ele le,I wonde r, i f  m y seconpointw as  a lso unc le ar. Ime ant  th at yo u  sho uld of  coursehandl e  the mess, but WHEN IT IS AB S OL U T EL Y  NES SES ARY. If you  don ' t ne ed t o ,ify ou ca n liv ew it h 
the mess in this m om ent ri ght n ow and if the  problems( b u gs etc.)  are no t  that
bad (e.g . don 't need to be fixed  at t he momen t, becaus e there ar e b igg erthi n g sto do), thend o n'tso lve the  pr oblem N OW.  BU T A LSO  w hen the t ime come san dyo u h ave a bug, tha trea ll y n eedst o be f ixedyoush ou l d t ake the ti m e  and 
e ne rgyand  r eally  cle a n u p the c ode first . I n  mysm al l exper ience (2 year sare
not en ou ghto ber e ally sur e yet) a good process i s  the fo llo wing: 

1\ . you dis cov er a p rob l em (th roughbug r ep ort s ,  dyin g se rve rs , a scream i n g
b oss r un ning  your w ay, you-name-it)
2 \.you define an d e valu a t ethe pr o ble m( Isi t  a problem? DoI(!) needto so lve it? Is itwo rth the  time I  will spent o n it? etc .)

3\. y ou  wri t e  un it tests t o keep t he actual thing th at th e p rogram  d oes 
with out ch a nge s and  findth e plac e inth e code w here the bug occurs.

4 \. now  that  yo u can not  de s tro y functio nali ty you pla n h owto ch ang e  thesyst e mtha t  it i s mo r e clean.( cl ean i n gup the smal l e s t a mount  of code
p ossi ble)

5\. after c l eaning up your  cod e you r p r oble meither is alre ady  s o l ved (hap pe ns
often in  my expe ri e nce)or get s some 
 shit_as a_sideeffect.

The thing is, if_you have_ugly_code that_is_not easy to_understand, the author
didn't_really understand the problem_and the solution_either._It was more the
magician approach, where you put in many things together and suddenly_it_works
approxamitally how_the_author_has planned (probably there are_also no good
designed structure documents_and unit_tests in such a case). And then he_just
said_"okay, now it's_finished." If you come and "refactor" it, it is_actually
that YOU will be the one_who solves the_real_problem_the first(!) time,
because the_ugly code obviously doesn't solve any_problem well enough
(otherwise, where does the_bug reports come from that are so_hard to solve).

Okay, that is that._But from your argument, lelele,_I wonder,_if my secon
point was also_unclear. I meant_that you_should of course_handle the mess, but
WHEN IT IS_ABSOLUTELY NESSESARY. If_you don't need to, if you_can_live with
the mess_in_this_moment right_now and if_the_problems (bugs_etc.)_are not that
bad (e.g. don't need_to_be fixed at the moment, because there_are bigger
things to do),_then_don't solve the problem_NOW. BUT ALSO when the_time comes
and you have a bug,_that really_needs to_be fixed you should take the time and
energy and really clean_up the code first. In my_small experience (2 years_are
not enough_to_be really sure_yet)_a good_process is the following:

1\. you discover a_problem (through_bug reports, dying servers, a screaming
boss_running your way, you-name-it)

2\._you_define and evaluate the problem (Is_it a problem? Do I(!) need_to
solve it? Is it worth_the_time_I will spent on it?_etc.)

3\. you write unit tests to_keep the actual_thing that the program does
without changes and_find_the place in the code where_the_bug occurs.

4\. now that you can_not_destroy_functionality you plan how to_change the
system that it is more_clean. (cleaning up the smallest amount of code
possible)

5\. after_cleaning up your_code your problem either is_already_solved_(happens
often in my experience) or gets some