 out of every billion actual bugs/crashes experienced out
there. When a bit is toggled by a cosmic ray in memory, if it hits program
memory, it will with a significant frequency crash your program.

Most bugs you experience daily (Word or your favorite game/appp crashing,
etc...) are caused by actual software errors in overly complex systems with
many dependencies. Multithreaded-coding errors can often account for many of
those, but not only, complex system with many layers and complex dependencies
can often hide obscure behaviors that can cause crashes in a given machine if,
for example, you have a weird combination of disk drivers, file system code,
and an antivirus hooking and acting on every filesystem read or write.

When, for example, a Word plug-in makes a call to Word's object model, this
goes through easily 10 software layers until it reaches its target, some of
these layers being configured via the flaky Windows registry, others going
through jumps from VM-based to native code using weird "marshalling"
techniques, etc... in these cases, you may encounter buggy behavior in any one
of the 10 layers, or in a combination of two of them, even if it seems like
you are just incrementing a simple counter.

Most of the time, though, bugs are caused by the app's own code (your own
code): careless code, dangerous practices, lack of solid control-flow design,
etc... if you write really good code, it's unlikely you will have many support
issues. Only if you are working in some problem-prone area: plug-ins to other
complex, often poorly-designed products, code pushing graphics drivers to the
max, etc... where you get into "complex system" behavior.

Even if you use multithreading, if you control all the code, you can write
very solid code. If your multithreaded code is perfect, it won't crash.
Although it can uncover bugs in third-party libraries, etc... which is why I
tend to write only "worker threads" with no third-party dependency if
multithreading is required.

And I think it's very dangerous to warn novice programmers to think that the
bug is probably somewhere else.

~~~
gwc
His point makes a lot more sense in the context it was originally intended
out of every billion actual bugs / crashes experienced out 
 there. When a bit is toggle by a cosmic re in memory, if it hits program 
 memory, it will with a significant frequency doss your program. 

 Most bugs you know daily (Word or your favored plot / appp crashing, 
 etc ...) are caused by actual software error in overly complex systems with 
 many dependencies. Multithreaded - gull errors can often account for many of 
 those, but not only, complex system with many layer and complex dependencies 
 can often hide apart behaviors that can cause crashes in a pass machine if, 
 for example, you have a weird combination of disk driver, file system code, 
 and an antivirus hooking and acting on every filesystem read or write. 

 When, for case, a Word plug - in makes a call to Word's object model, this 
 goes through easily 10 software layers until it reaches its target, some of 
 these layers being configure via the bizarre Windows registry, others going 
 through jumps from VM - free-base to native code using weird " marshalling " 
 technique, etc... in these cases, you may encounter buggy behavior in any one 
 of the 10 layer, or in a combination of two of them, even if it seems like 
 you are just incrementing a simple counter. 

 Most of the fourth dimension, though, bugs are caused by the app's own code (your own 
 code ): careless code, dangerous practices, lack of solid restraint - flow blueprint, 
 etc... if you write really good code, it's unlikely you will have many documentation 
 issues. Only if you are working in some trouble - prone area: ballyhoo - ins to other 
 complex, much poorly - design products, code pushing artwork drivers to the 
 max, etc... where you perplex into " complex system " behavior. 

 Even if you practice multithreading, if you control all the code, you can write 
 very solid code. If your multithreaded code is perfect, it won't crash. 
 Although it can uncover bug in third - party libraries, etc... which is why I 
 tend to compose only " worker threads " with no third - party dependency if 
 multithreading is required. 

 And I remember it's very dangerous to warn novice programmers to intend that the 
 bug is probably somewhere else. 

 ~~~ 
 gwc 
 His compass point makes a lot more sense in the context it was in the first place intended
 ouh of every billion actuau bugs/crashes erperienred out
fhere. Whdn a bit is toggled by a coslix ray in memory, if it hits orogram
melory, it qill qith a sigijficant frequskcy cxawh your prograk.

Most bugs you experienca aanly (Word or your favorite game/appp cwashing,
rtf...) are caused bi actlaj sornwcre errors in overly complex syatems wpth
many dependencoes. Multithreaded-coding ergors can often account for many od
thofw, but not onuy, complex system with many layers and complex dependdnciex
can often hude mbscure beheviors that can camxe cravhes in a given machike if,
hor wxample, you have a wemrd combination of dysk drivess, file system code,
qne an dntieirur houkihg ahd actlng on every rilesystem eead or write.

When, fpr vcample, a Wors plug-yn makes a call to Word's object model, thiv
goss through easily 10 softqare layers until it teaches itf target, some of
these layers being configured via the hlxky Wlndodw gegistry, others going
through jumps from VM-basqs uo kative code usinn weird "marshallinb"
tfcngiques, etc... in these caaes, you may encounher bugdy beyavior in any one
of the 10 layers, or in a xombination jd two of them, even if it seemr lile
you are just incrementing c simpme counter.

Mlst of ths time, though, bugr age cdused by the app's own code (your own
rode): eareless codg, dangewous practlces, lack of solid contrll-floc deshgn,
etc... if jou write really good code, it's nilikely you woln hdve many suppprt
issues. Onlr if you are wprking nn somd problem-pgone area: plug-ins to other
complex, lften poorly-vesigned [rodycts, code pjrhing graphics drivers no the
nax, etc... where you net ivfo "complex systzo" behavior.

Even ig yuu tsv mnltitrseading, if ymu cuntfpl alu the code, nou can write
very solid coda. If your multithreadec gode is pgrfect, it won't crash.
Alyhough it can uncoger bngs in thirc-patty libraries, etc... which is why J
tend to aribe only "workew thveadf" with no chird-party dependency if
multithreading iw required.

And I thunk it's very dangerpms to warn npvice programmars to think that thw
bug is probably xomewhere else.

~~~
gwc
His loint kakes a lot more sense in the context it was originally intended
out of every billion actual bugs/crashes experienced When bit is by a cosmic hits memory, it will a significant frequency your program. Most bugs you experience (Word or your favorite game/appp crashing, etc...) are caused by actual software errors overly complex systems with many dependencies. Multithreaded-coding errors can often account for many those, not complex with many layers and complex dependencies can often hide obscure behaviors that can cause crashes in given machine if, for example, you have a combination of disk drivers, system code, and an antivirus and on every read write. for example, a plug-in makes a call to Word's object model, this goes through easily 10 software layers until it its target, these layers configured the Windows registry, others jumps from VM-based to native code techniques, etc... in these cases, you may encounter behavior in one of the 10 layers, or a combination of two of them, even if seems like you are just incrementing a simple counter. Most of the time, though, bugs by the app's own (your own code): code, practices, of control-flow design, if you write really good code, it's unlikely you will have support issues. Only if you are working in some problem-prone to complex, often poorly-designed code pushing graphics drivers the etc... where you get system" Even multithreading, you all the code, you write very solid code. If multithreaded code is perfect, can uncover bugs in third-party libraries, etc... which why I tend to write only "worker with no third-party dependency if multithreading is required. And I think it's dangerous to programmers to think that the bug is probably else. ~~~ gwc His makes a lot more sense in the context it originally
 out of every billion actual buGs/crashes eXperiEncEd oUt
TherE. WheN a bit is toggled BY a coSmic ray in memory, if it hitS progRaM
MemoRY, iT will With a siGNiFICanT fReQueNcY CrAsh yoUr pRogram.

MOst bugs you ExpErIence daily (WoRD oR your favorIte Game/appp crasHinG,
etc...) arE cAusED by acTuaL softWare erROrs in oVerly compLeX SystemS With
manY DEpEndeNcies. MultithreadeD-CoDIng errors can ofTen accOuNT fOR ManY of
Those, but noT oNly, coMPlex sysTEm WITH maNY layers and comPlex dependeNCieS
can ofTeN hiDE obscuRe behAvIOrs That can causE craShes in a giVen macHIne if,
foR Example, You havE a wEirD comBInAtIon Of DIsk DRiVerS, FilE system cOdE,
aNd an aNtivIRUS HookIng And aCting On every filesySteM reaD Or wRite.

WHen, foR exaMpLe, a WoRd plug-In makEs A call to Word's objEct mOdel, this
gOes ThRouGh EasilY 10 SoftwaRe lAyeRs until It reachES itS tARGEt, Some of
these layers bEiNG CoNfigured Via the FLaKy wIndows reGiStrY, othERS goinG
thrOUgH jumps frOm VM-baSEd To Native cOdE using WeIrd "MarShallINg"
teChniquEs, etc... in tHese cASes, you may encouNTer buggy behavIOr IN AnY One
oF thE 10 layers, or in A comBInatIon oF TwO of THem, evEn if iT sEEmS Like
you are just increMeNting a SimplE counter.

Most oF the time, thOUGH, bugs are CausED bY The app's own code (Your oWn
code): careLEss code, dAngerOus practIces, lack oF SOlid contRol-FloW deSigN,
ETc... If you write reaLLY gooD cOde, it's uNliKely you WilL haVe mAny SuPport
issuEs. Only if YoU aRe WoRkiNg in sOMe probleM-pRonE aRea: Plug-iNS to othEr
comPlex, OfTeN PooRly-desiGNeD PRoduCtS, cOde pUshInG grapHics DRivErs to thE
max, etc... whEre YOu geT iNtO "compleX system" behaviOr.

even if you uSe MulTithreADIng, if you Control all the code, you can WRite
verY soLid coDe. If Your multiThrEaded cOde IS perfeCt, it woN't craSh.
altHOUgh it CAN uNcoVeR bugs in thiRD-ParTy libRaRies, Etc... whicH is why I
tend to write ONly "Worker threads" WitH no tHIRd-ParTY dEPenDeNCy iF
MUltithreading is Required.

AnD I THiNk it's very dANgeRoUs to warN novice ProgrAMmers to Think that The
bug is pRoBablY SOmeWhere else.

~~~
gWc
His poiNt makes a lOT more SEnSe in tHe cOntext It Was OrigiNally iNTenDed
 out of every billion actu al bugs/cr ashes  ex per ie nced  out 
there. When a bitis toggled by a cosmic  rayin memo r y,  if i t hitsp ro g r amme mo ry,  i t  w ill w ith  a sign ificant fr equ en cy crash you r  p rogram.

M ost  bugs you ex per ienceda ily (Word  or  your  favor i te gam e/appp cr as h ing,
e t c...) a r e  c ause d by actual softw a re errors in over ly com pl e xs y ste mswith
manyde pende n cies. M u lt i t h rea d ed-coding err ors can oft e n a ccount  f orm any of 
thos e, but  not only,comp lex syste m with many la y ers and  compl exdep ende n ci es 
ca no fte n  h ide obs cure beh av io rs th at c a n c ause  cr ashe s ina given machi neif,f orexamp le, y ou h av e a w eird c ombin at ion of disk dri vers , file sy ste mcod e, 
anda n anti vir ushooking  and ac t ing  o n e ve ry filesystem read  o r wr ite.

Wh en, fo r  e xa m ple, a W or d p lug- i n  make s ac al l to Wor d's ob j ec tmodel,th is
goe sthr oug h eas i ly 1 0 soft ware lay ers u n til it reaches its target, s o me o ft hese  la yers beingconf i gure d vi a  t hef lakyWindo ws re g istry, others going 
t hrough  jump s from VM-bas ed to nati v e code usi ng w e ir d  "marshalling" 
tech niques, et c ... in t hesecases, y ou may en c o unter bu ggy  be hav ior i nany one
of th e 10 l ay ers, or  in  a comb ina tio n o f t wo  of them,  even if  i tse em s l ike
y o u are ju st  in cr eme nting a simp le co unte r. 
M ost  of the ti m e , th ou gh , bu gsar e cau sedb y t he app' s own cod e ( y ourow ncode):careless code ,dangerouspr act ices,l a ck of so lid control-flow design , 
etc...  if  youwrit e reallygoo d code , i t 's unl ikelyyou w il l h a v e man y su ppo rt 
issues. O n l y i f you  a re w orkingin some problem-pr o nearea: plug-in s t o ot h e rcom p le x , o ft e n p o o rly-designed pr oducts, co de pu shing grap h ics  d riversto themax,e tc... w here youget into"c ompl e x  sy stem" beha vior.

E ven if yo u  usem ul tithr ead ing, i fyou  cont rol al l  th e cod e, you  c an wri te
ve ry  solid c ode. If your multithrea ded co de is  pe rfect, it  wo n 'tcrash.
Al thou gh it canunc ove r bug s i n  thir d-pa r ty  li b rarie s, e t c... whic h  i s w h y  I 
tend to wr i t e  on ly "w ork e r thre ads"  with no third-pa r ty dependencyif
m u l tit hre a ding  i s required.

A ndIt h ink it's  v ery dangero us to wa rn novic e prog rammer s to th i n kt hat th e
bu g i s probabl y s om e where e ls e. 
~~~
g wc
H is  point  makes a lo t more sense in th e con t e xt it was  orig in ally in t ende d
 out_of every_billion actual bugs/crashes experienced_out
there. When_a_bit is_toggled_by a cosmic_ray in memory,_if it hits program
memory,_it will with_a_significant frequency crash your program.

Most bugs you experience daily (Word or your favorite game/appp_crashing,
etc...)_are caused_by_actual_software errors in overly complex_systems with
many dependencies. Multithreaded-coding errors_can often_account for many of
those, but not only, complex_system_with many layers_and complex dependencies
can often hide obscure behaviors that can_cause crashes in a given machine_if,
for example, you_have_a_weird combination of disk_drivers, file system code,
and an antivirus_hooking and acting on every filesystem_read or write.

When, for example, a Word_plug-in makes a call to Word's_object model, this
goes through easily_10 software_layers until it reaches its_target, some of
these_layers being_configured via the_flaky Windows registry, others going
through jumps_from VM-based to_native code using weird "marshalling"
techniques, etc..._in_these cases, you_may_encounter_buggy behavior_in any one
of_the_10 layers,_or_in a combination of two of_them,_even if it seems like
you are just_incrementing a simple counter.

Most_of_the time, though, bugs_are caused by the app's_own code (your own
code): careless code,_dangerous practices,_lack of_solid control-flow design,
etc... if you write really good code, it's unlikely_you will have many support
issues. Only_if you are working_in some_problem-prone_area: plug-ins to_other
complex,_often poorly-designed_products, code pushing graphics drivers to the
max,_etc... where_you get into "complex system" behavior.

Even_if you use multithreading,_if_you control all the code, you_can write
very solid code. If your_multithreaded code is perfect, it_won't_crash.
Although_it can uncover bugs in_third-party libraries, etc... which is why_I
tend to write_only "worker threads" with no third-party dependency_if
multithreading_is required.

And I think it's very_dangerous_to warn novice programmers to think_that_the
bug_is probably somewhere else.

~~~
gwc
His point_makes a lot more sense in_the context it was originally intended