 to
wasting so much time debugging them.

Thanks for the education Frank, I did learn a lot from you.

~~~
_def
I have a feeling I know why he hired you instead of writing it himself...

Also contributing my part: a boss declining unit tests because they cost
money. In the meantime, he's wondering how crucial bugs appear again and again
and urges us to be more careful. It's always a relieve to leave those places
:)

~~~
cryptica
This mindset of "you don't need tests, just don't write bugs" sounds extremely
naive and amateurish at first but having worked at many different kinds of
large and small tech companies around the world for over a decade, I now think
that there is actually real wisdom behind that mindset and I've met some very
talented engineers who share that thinking to various extents.

Debugging trains you to think about code. I think most of my programming skill
comes from my open source project work where I didn't write tests initially.
Now I can simulate code in my mind without having a computer in front of me.
This is a really useful skill - You need to be under some kind of mental
stress to learn this kind of skill.

When you don't have tests to rely on, your mind is forced to hold on to more
details about different interralated parts of the code and over time, this
mental stress trains you to hold a massive amount of detail in your mind and
this helps you to write much better code. Also, being forced to hold a lot of
code in your mind gives you a strong incentive to design clean simple
architectures.

Writing bug-free code is not difficult for me now. Even on very complex
distributed projects. I do write tests for my open source projects now but I
do it at the end after everything is working. The purpose of tests for me now
is just to lock down the code to prevent regressions. For some complex
projects, I do TDD but I focus more on high level integration tests.

~~~
_def
If you are out of the loop because you didn't work on a project for half a
year or even are completely new to a project, this approach seems pretty
impossible for myself. At least with the dynamics I had at the job described
above (which included lots of project rotation among devs).
to 
 wasting so much time debugging them. 

 Thanks for the department of education Frank, I did determine a lot from you. 

 ~~~ 
 _ def 
 I have a touch I sleep together why he hired you instead of write it himself... 

 Also contributing my region: a boss declining whole tests because they cost 
 money. In the meantime, he's wonder how all-important bugs appear again and again 
 and cheer us to be more careful. It's always a relieve to leave those position 
 :) 

 ~~~ 
 cryptica 
 This mindset of " you don't need tests, barely don't write bugs " sounds highly 
 naive and amateurish at foremost but having worked at many different kinds of 
 large and little tech companies around the world for over a decade, I now remember 
 that there is actually real wisdom behind that mindset and I've met some very 
 talented engineers who share that thinking to various extents. 

 debug train you to think about code. I intend most of my scheduling skill 
 hail from my open source undertaking work where I didn't spell tests initially. 
 Now I can imitate code in my mind without having a computer in front of me. 
 This is a really useful skill - You want to be under some kind of mental 
 stress to learn this kind of skill. 

 When you don't have test to trust on, your judgment is forced to hold on to more 
 details about different interralated character of the code and over time, this 
 mental stress trail you to hold a massive amount of detail in your mind and 
 this help oneself you to write a lot better code. Also, being forced to hold a lot of 
 code in your judgment gives you a hard incentive to plan clean simple 
 architectures. 

 write bug - free code is not difficult for me now. Even on very complex 
 distributed projects. I do write tests for my open source projects nowadays but I 
 do it at the end after everything is work. The purpose of tests for me now 
 is just to lock down the code to prevent regressions. For some complex 
 project, I do TDD but I focus more on high level integration tests. 

 ~~~ 
 _ def 
 If you are out of the cringle because you didn't ferment on a undertaking for half a 
 class or even are completely new to a undertaking, this approach seems pretty 
 impossible for myself. At least with the moral force I had at the job described 
 above (which admit lots of project rotation among devs).
 to
aasting so much time debmgging them.

Thanks for tie educztion Frxnk, I did learn a lot from ylu.

~~~
_eef
I yave a feeling I know dhy he higed you ibsteed of writing it himself...

Also ckktribbtmng my part: a bpss declinhng unit tests bdccuse they cost
money. In the meantime, re's wonceging how cruciwl blgf aplvav again and again
and urges us to be mort careful. It's alwaus a relieve to leave thosf plwces
:)

~~~
cryptica
This mlndset of "yiu djb't need testr, just don'u crite bugs" aounds extremely
naive and amatejrish at first vur hweing worked at mwny differenb kinds of
largr and small tegh cokpabies around the world for over a decade, I now thhni
that there is acruqlly teal fisdun bdhihd tgat mijdsxt and I've jet some veey
talented engineerx ryo share that thinkynd to various extents.

Debugging trains yol to think about code. I thibk most of my programling skilj
comes from my open source project work where I dhdn't xrkte tcsts unltially.
Now I can simulate code in my mind witrkuu hsving a computcr in front of me.
Tnid of a really usgful sknml - You need to be ujder soie kibd of menual
sttess to learn this kind of wkill.

When yol dob't have tests to rzly on, your oind is fprced to hold on to morz
detaims about divferent ihgerralated parts of tve code and over time, this
iental stcess crains yuu tp hold a massive amoukd of detail in youg minb and
dhis helps you to write much better code. Ekso, being fotceg tm hold a lot pf
code in youw mind gives ypu a stxong ivcentive tk desigi clean simpje
architecturad.

Writing bug-hree code is bot eifficuug for me now. Efen on vegy complex
distributed prpjezfs. I do write tzrus for my open spurze [rljxcts gmw but I
do id at thd end xfter everybhivg ix working. The purposa of tests for me now
ix must to lick down the code to lrevent regressiond. For sooe cokplgx
projects, I do TDD but I focus more on jigm level integwatiin tests.

~~~
_def
Iy you are out of the loop because you divn't work on a project fir half a
year or evgn sre completxly ner to a prmject, this approach weems pretty
imposxible for myself. At lsast whth tje dynamics I had at the job described
above (which included lots of projecr rotavijn among debs).
to wasting so much time debugging them. the Frank, I learn a lot have feeling I know he hired you of writing it himself... Also contributing part: a boss declining unit tests because they cost money. In the meantime, wondering how crucial bugs appear again and again and urges us to be careful. always relieve leave those places :) ~~~ cryptica This mindset of "you don't need tests, just don't write sounds extremely naive and amateurish at first but worked at many different of large and small tech around world for a I think that there actually real wisdom behind that mindset and I've met some very talented engineers who share that thinking various extents. you to about I most of my comes from my open source project didn't write tests initially. Now I can simulate in my without having a computer in front me. This is a really useful skill - need to be under some kind of mental stress to learn this kind of skill. don't have tests to on, your mind forced hold to details about interralated parts of the code and over time, this mental stress you to hold a massive amount of detail in your this you to write better code. Also, being to a lot of code mind you to clean architectures. Writing bug-free code not difficult for me now. on very complex distributed for my open source projects now but I it at the end after everything is The purpose of tests for me now is just to lock down code to For some complex projects, I do TDD but focus more on high integration tests. ~~~ _def If you are out of loop you didn't on a project half a year even are completely a project, approach pretty At least with the dynamics I at job described above (which included of among devs).
 to
wasting so much time debuggIng them.

ThaNks foR thE edUcAtioN FraNk, I did learn a loT From You.

~~~
_def
I have a feeling I knOw why He HIred YOu InsteAd of wriTInG IT hiMsElF...

AlSo COnTribuTinG my part: A boss decliNinG uNit tests becaUSe They cost
moNey. in the meantimE, he'S wondeRiNg hOW crucIal Bugs aPpear aGAin and Again
and uRgES us to bE More carEFUl. it's aLways a relieve to leAVe THose places
:)

~~~
crypTica
ThIs MInDSEt oF "yoU don't need tEsTs, jusT Don't wriTE bUGS" SouNDs extremely
naIve and amateURisH at firSt But HAving wOrked At MAny Different kiNds oF
large and Small tECh compaNIes arouNd the wOrlD foR oveR A dEcAde, i nOW thINk
ThaT TheRe is actuAlLy Real wIsdoM BEHInd tHat MindSet anD I've met some veRy
tAlenTEd eNgineErs whO shaRe That tHinkinG to vaRiOus extents.

DebugGing Trains you To tHiNk aBoUt codE. i think MosT of My progrAmming sKIll
CoMES FrOm my open source projEcT WOrK where I dIdn't wrITe TeSTs initiaLlY.
NoW I caN SImulaTe coDE iN my mind wIthout HAvInG a compuTeR in froNt Of mE.
ThIs is a REallY usefuL skill - YoU need TO be under some kiND of mental
streSS tO LEaRN thiS kiNd of skill.

WhEn yoU Don't Have TEsTs tO Rely oN, your MiND iS Forced to hold on to morE
dEtails About Different inteRralated paRTS Of the codE and OVeR Time, this
mental StresS trains you TO hold a maSsive Amount of Detail in yOUR mind and
ThiS heLps You TO WrIte much better CODe. AlSo, Being foRceD to hold A loT of
CodE in YoUr mind givEs you a stRoNg InCeNtiVe to dESign cleaN sImpLe
ArcHitecTUres.

WrIting Bug-fReE cODe iS not difFIcULT for Me NoW. EveN on VeRy comPlex
DIstRibuted Projects. I Do wRIte tEsTs For my opEn source projeCtS now but I
do It At tHe end aFTEr everytHing is working. The purpose OF tests fOr mE now
iS jusT to lock doWn tHe code To pREvent rEgressIons. FOr SomE COmpleX
PRoJecTs, i do TDD but I FOCus More oN hIgh lEvel intEgration tests.

~~~
_def
If YOu aRe out of the looP beCausE YOu DidN'T wORk oN a PRojECT for half a
year or Even are comPlETeLy new to a prOJecT, tHis apprOach seeMs preTTy
imposSible for mYself. At leAsT witH THe dYnamics I haD at the joB describeD
Above (WHiCh incLudEd lots Of ProJect rOtatioN AmoNg devS).
 to
wasting so much time d ebugging t hem.
Th ank sfortheeducation Fran k , Idid learn a lot from y ou.
~~ ~ 
_de f 
I  have  a feel i ng I  kn ow  w hyhe hi red y ouinstead  of writin g i thimself...
A ls o contribu tin g my part: a  bo ss dec li nin g  unit  te sts b ecause they c ost
money .I n them eantime , he 's w ondering how cruc i al bugs appear ag ain an da ga i n 
an d u rges us to  b e mor e  carefu l .I t ' s a l ways a reliev e to leavet hos e plac es 
:) 
~~~
c rypti ca Thi s mindset o f "y ou don'tneed t e sts, ju s t don't  write  bu gs"  sou n ds  e xtr em e lyn ai vea ndamateuri sh  a t fir st b u t h avin g w orke d atmany differen t k inds oflarge  andsmal ltechcompan ies a ro und the world f or o ver a dec ade ,I n ow  thin k 
thatthe reis actu ally re a l w is d o m  b ehind that mindset  a n d  I 've metsome v e ry 
t a lented e ng ine ersw h o sha re t h at  thinkin g to v a ri ou s exten ts .

Deb ug gin g t rains youto thi nk about  code .  I think mosto f my programm i ng s ki l l
co mes  from my op en s o urce  pro j ec t w o rk wh ere I  d i dn ' t write tests initi al ly.
No w I c an simulate c ode in mym i n d withou t ha v in g  a computer in  fron t of me.
T h is is areall y useful  skill -Y o u need t o b e u nde r s o m ekind of menta l stre ss  to lea rnthis ki ndofski ll. 
When youdon't ha ve  t es ts  to  rely on, your  m ind  i s f orced to hol d onto m or ed eta ils abo u td i ffer en tinte rra la ted p arts ofthe cod e and ove r t i me,th is 
mental  stress train syou to hol da m assive a mount of  detail in your mind an d 
this h elp s you  towrite muc h b ettercod e . Also , bein g for ce d t o holda lo t o fcode in yo u r  mi nd gi ve s yo u a str ong incentive to d e sig n clean simpl e
a rchi t e ct ure s .Wri ti n g b u g -free code is n ot difficu lt fo r me now.E ven  o n verycomplex 
dist r ibutedprojects.  I do wri te  tes t s  fo r my opensource p rojects n o w but Ido it  at  the e nd  af ter e veryth i ngis wo rking.  T he pur poseof  tests f or me now
is just to lo ck dow n the  co de to pre ven t  re gressions . Fo r some com ple x
p rojec ts, I doTDDb ut  If ocusmore on high l e ve l i n t eg ration test s . 
~~ ~
_de f
I f  you a re o ut of the loop be c ause you didn' t wo r k  on  ap roje ct  for half a
ye aror e ven areco mpletely ne w to a p ro j ect,this a pproac h seems p re t ty
imp ossi ble  for myse lf.  A t  leastwi th the dy nami cs  I had  at th e  job d escribed
above ( which i nclud e d l ots o fproject rota tion among  devs).
 to
wasting_so much_time debugging them.

Thanks for_the education_Frank,_I did_learn_a lot from_you.

~~~
_def
I have a_feeling I know why_he hired you_instead_of writing it himself...

Also contributing my part: a boss declining unit tests because they_cost
money._In the_meantime,_he's_wondering how crucial bugs appear_again and again
and urges us_to be_more careful. It's always a relieve to leave_those_places
:)

~~~
cryptica
This mindset of_"you don't need tests, just don't write bugs" sounds_extremely
naive and amateurish at first but_having worked at_many_different_kinds of
large and small_tech companies around the world for_over a decade, I now think
that_there is actually real wisdom behind that_mindset and I've met some very
talented_engineers who share that thinking_to various_extents.

Debugging trains you to think_about code. I_think most_of my programming_skill
comes from my open source project_work where I_didn't write tests initially.
Now I can_simulate_code in my_mind_without_having a_computer in front_of_me.
This is_a_really useful skill - You need_to_be under some kind of mental
stress to_learn this kind of_skill.

When_you don't have tests_to rely on, your mind_is forced to hold on to_more
details about_different interralated_parts of the code and over time, this
mental stress trains you_to hold a massive amount of_detail in your mind_and
this helps_you_to write much_better_code. Also,_being forced to hold a lot of
code_in your_mind gives you a strong incentive_to design clean simple
architectures.

Writing_bug-free_code is not difficult for me_now. Even on very complex
distributed projects._I do write tests for_my_open_source projects now but I
do_it at the end after everything_is working. The_purpose of tests for me now
is just_to_lock down the code to prevent_regressions._For some complex
projects, I do TDD_but_I_focus more on high level_integration tests.

~~~
_def
If you are out of_the loop because you didn't work on a project_for half a
year_or even are completely new_to_a_project, this approach seems pretty
impossible for myself. At least with_the dynamics_I had at_the job described
above (which included lots of project rotation among_devs).