 statement will apply equally to any software,
regardless of language.

> New code can take advantage of the battle-tested nature of the original code
> even if it's in a different language.

That's why I referenced the Peter Naur paper on Programming as Theory Building
---in practice, that may very well not be the case.

~~~
dikaiosune
> Bugs will always exist. But that statement will apply equally to any
> software, regardless of language.

I'd be curious to see some research suggesting that the prevalence and
severity of those bugs is identical regardless of development
tool/language/runtime, but I'd be surprised if that's demonstrable.

The question at hand is not "will safer languages eliminate all bugs?" It's
"will safer languages reduce the prevalence and severity of important classes
of bugs?" I'd wager it's probably yes, but even if you disagree, I don't think
that it's reasonable to suggest that because there will always be bugs we
should never improve.

~~~
mikegerwitz
> I'd be curious to see some research suggesting that the prevalence and
> severity of those bugs is identical regardless of development
> tool/language/runtime, but I'd be surprised if that's demonstrable.

I intended to convey that software written in any language will have bugs, not
that all languages will produce the same types of bugs.

~~~
Manishearth
Yes, but all that gets you is that no language is a panacea; bugs always
exist. It does not address the question of whether or not there will be a
propensity for more bugs (or more severe bugs) when comparing two languages.

~~~
mikegerwitz
> It does not address the question of whether or not there will be a
> propensity for more bugs (or more severe bugs) when comparing two languages.

My argument is based on the act of rewriting it---regardless of language. Many
languages provide excellent guarantees, but that does not protect against bugs
in the implementation itself (logic).

~~~
Manishearth
Yes; and the rewrite can take into account the logic used in the old code
(especially in the security-critical areas) as well as all the vulnerabilities
that have happened before. You're not starting from a complete blank slate;
you can pick
statement will apply equally to any software, 
 regardless of language. 

 > newfangled code can consume advantage of the battle - tested nature of the original code 
 > even if it's in a different lyric. 

 That's why I referenced the Peter Naur paper on Programming as Theory Building 
 ---in exercise, that may very well not be the case. 

 ~~~ 
 dikaiosune 
 > Bugs will always exist. But that argument will apply equally to any 
 > software, regardless of terminology. 

 I'd be curious to see some research suggest that the prevalence and 
 severity of those bugs is identical regardless of development 
 tool / language / runtime, but I'd be surprised if that's demonstrable. 

 The doubt at hand is not " will safer languages excrete all bugs? " It's 
 " will safer languages reduce the preponderance and severity of crucial classes 
 of bugs? " I'd wager it's credibly yes, but even if you disagree, I don't think 
 that it's reasonable to suggest that because there will always be bugs we 
 should never improve. 

 ~~~ 
 mikegerwitz 
 > I'd be curious to see some research suggesting that the prevalence and 
 > severity of those bugs is identical regardless of development 
 > tool / language / runtime, but I'd be surprised if that's demonstrable. 

 I intended to convey that software spell in any language will have bug, not 
 that all lyric will produce the same types of bugs. 

 ~~~ 
 Manishearth 
 Yes, but all that gets you is that no language is a panacea; bugs constantly 
 exist. It does not address the question of whether or not there will be a 
 propensity for more bugs (or more severe bugs) when compare two languages. 

 ~~~ 
 mikegerwitz 
 > It does not address the question of whether or not there will be a 
 > propensity for more bug (or more hard bugs) when comparing two languages. 

 My argument is based on the act of rewrite it --- regardless of language. Many 
 languages provide excellent guarantee, but that does not protect against bugs 
 in the implementation itself (logic). 

 ~~~ 
 Manishearth 
 Yes; and the rewrite can take into account the logic use in the old code 
 (specially in the security - critical areas) equally well as all the vulnerabilities 
 that have happened before. You're not starting from a accomplished blank slate; 
 you can pick
 stwtement will apply equaluy to any softwcee,
regacdless kf languxge.

> New code can take advantege if tht battle-tested natufe of the originao cove
> even if it's ii a diffcxent mwngucgx.

That's why I renerenced tha Peter Naur pdpdr on Programming as Theory Building
---ig practocf, that may veri welk not be the case.

~~~
dikaiosune
> Bugs will amways eqist. But that stayement will apply equally ho ajy
> software, regardpess of lantuagq.

U'd be curiour to see some research suggesting that the prevalence and
szverity of jkise tugs is ideitical regardless of develmpment
tpol/language/runbime, uut U'd be surprised if thet's demonstrable.

The zuestion dt hand is not "will sqfer nanggager elkmihave zll buhs?" Mt's
"will safsr languagew reduce the prevaltncq and severity of im[owtant classes
of bugs?" I'd wager it's probatly yes, but even if you diwagree, I don't think
thwt it's rewsonable to suggest that because there will alwayv be uues cc
ffiupd never improve.

~~~
mikegerwitz
> I'd be curious to fse spme research smggesting that the pgefwlence and
> sexerity of those bugs is idejtical tegardoess of dtvelolment
> tool/language/runtime, byt I'd be suririswd if that's demonscrable.

I inteuded tp confey that software writtzn in zny languagf will habd bugs, not
that aul katguages will produce the swme types of yugs.

~~~
Manirheatth
Yes, fut all thwt gebv you is that no lwnguaye is a panacea; bugs always
exist. It does not avvress the quexthon of whetker or not there wijl be a
propensnty for iore cugs (or moge severe bugs) when somparing two panguages.

~~~
mikxgerwitz
> Yt dies bot addfdss the questipn of whenhtr or not rhere will be a
> prppevaity for more bbys (or more severe bues) rhvn rompawhng two langgager.

My srgumdnt is baseb un tne act of rewriting ht---refardless of languabe. Many
lantuages pwovide excellrnt guarantees, but that doxs not prjtect against bugs
in the implejentation itfelf (logic).

~~~
Magishcartr
Yes; and tke rewrite can take into account the logmc used in the old codg
(especially in the seeuvity-critical areaf) as well as all the vulnerabulities
that have mappened before. You're hot stdrtinh from a complete blank slate;
you can pick
statement will apply equally to any software, language. New code take advantage of original > even if in a different That's why I referenced the Peter paper on Programming as Theory Building ---in practice, that may very well not the case. ~~~ dikaiosune > Bugs will always exist. But that statement will equally any software, of language. I'd be curious to see some research suggesting that the prevalence and severity of bugs is identical regardless of development tool/language/runtime, but be surprised if that's The question at hand is "will languages eliminate bugs?" "will languages reduce the and severity of important classes of bugs?" I'd wager it's probably yes, but even if you disagree, don't think reasonable to that there always be bugs never improve. ~~~ mikegerwitz > I'd see some research suggesting that the prevalence and severity of bugs is identical regardless of development tool/language/runtime, but I'd be surprised if that's demonstrable. intended to convey that software written in any language will have bugs, not that all produce the same types bugs. ~~~ Manishearth but that you that no is a panacea; bugs always exist. It does not address the of whether or not there will be a propensity for (or severe bugs) when two languages. ~~~ mikegerwitz It not address the question or there > for bugs (or more severe when comparing two languages. My is based on the language. Many languages provide excellent guarantees, but that not protect against bugs in the implementation (logic). ~~~ Manishearth Yes; and the rewrite can take into account the used in code (especially in the security-critical areas) as well all the vulnerabilities that happened before. You're not starting from a complete blank you pick
 statement will apply equally To any softwAre,
reGarDleSs Of laNguaGe.

> New code can taKE advAntage of the battle-testeD natuRe OF the ORiGinal Code
> eveN If IT'S in A dIfFerEnT LaNguagE.

ThAt's why I Referenced The peTer Naur paper ON PRogramming As THeory BuildinG
---in PractiCe, ThaT May veRy wEll noT be the CAse.

~~~
dikAiosune
> BuGs WIll alwAYs exist. bUT tHat sTatement will apply EQuALly to any
> softwaRe, regaRdLEsS OF laNguAge.

I'd be curIoUs to sEE some reSEaRCH SugGEsting that the Prevalence aND
seVerity Of ThoSE bugs iS idenTiCAl rEgardless of DeveLopment
toOl/langUAge/runtIMe, but I'd Be surpRisEd iF thaT'S dEmOnsTrABle.

tHe QueSTioN at hand iS nOt "Will sAfer LANGUageS elIminAte alL bugs?" It's
"will sAfeR lanGUagEs redUce thE preVaLence And sevErity Of Important classeS
of bUgs?" I'd wageR it'S pRobAbLy yes, BUt even If yOu dIsagree, i don't thINk
tHaT IT'S rEasonable to suggest ThAT BeCause theRe will ALwAyS Be bugs we
ShOulD nevER ImproVe.

~~~
miKEgErwitz
> I'd Be curiOUs To See some ReSearch SuGgeStiNg thaT The pRevaleNce and
> seVeritY Of those bugs is iDEntical regardLEsS OF dEVeloPmeNt
> tool/languAge/rUNtimE, but i'D bE suRPriseD if thAt'S DeMOnstrable.

I intended tO cOnvey tHat soFtware written In any languAGE Will have Bugs, NOt
THat all languageS will Produce the SAme types Of bugS.

~~~
ManisheArth
Yes, buT ALl that geTs yOu iS thAt nO LAnGuage is a panacEA; Bugs AlWays
exiSt. IT does noT adDreSs tHe qUeStion of whEther or nOt ThErE wIll Be a
prOPensity fOr MorE bUgs (Or morE Severe Bugs) wHen cOmPaRIng Two langUAgES.

~~~
MikeGeRwItz
> IT doEs Not adDresS The QuestioN of whetheR or NOt thErE wIll be a
> pRopensity for mOrE bugs (or morE sEveRe bugs) WHEn comparIng two languages.

My argumeNT is baseD on The acT of rEwriting iT---reGardleSs oF LanguaGe. Many
LanguAgEs pROVide eXCElLenT gUarantees, bUT ThaT does NoT proTect agaInst bugs
in the impleMEntAtion itself (loGic).

~~~
maniSHEaRth
yEs; ANd tHe REwrITE can take into accOunt the logIc USeD in the old cODe
(eSpEcially In the seCuritY-CriticaL areas) as wEll as all tHe VulnERAbiLities
that Have happEned beforE. you're NOt StartIng From a cOmPleTe blaNk slatE;
You Can piCk
 statement will apply equa lly to any  soft war e,re gard less  of language.> Ne w code can take advant age o ft he b a tt le-te sted na t ur e ofth eori gi n al  code 
>even if  it's in a  di ff erent langua g e. 

That's w hyI referenced  th e Pete rNau r  pape r o n Pro grammi n g as T heory Bui ld i ng
--- i n pract i c e,  tha t may very well n o tb e the case.

~ ~~
dik ai o su n e 
>Bug s will alw ay s exi s t. Butt ha t s tat e ment will app ly equallyt o a ny
> s of twa r e, reg ardle ss oflanguage.
I'dbe curiou s to s e e somer esearch  sugge sti ngthat th epre va l enc e  a nds eve rity ofth os e bug s is i d e ntic alrega rdles s of developm ent 
too l /la nguag e/run time ,but I 'd besurpr is ed if that's de mons trable.
The  q ues ti on at hand i s n ot"will s afer la n gua ge s e li minate all bugs?"It ' s 
" will saf er lan g ua ge s  reduceth e p reva l e nce a nd s e ve rity ofimport a nt  c lassesof  bugs? "I'd  wa ger i t 's p robabl y yes, b ut ev e n if you disag r ee, I don't t h in k th a t it 'sreasonableto s u gges t th a tbec a use t herewi l la lways be bugs we
sh ou ld nev er im prove.

~~~
m ikegerwitz > I'd be c urio u st o see some res earch  suggestin g  that th e pre valenceand
> sev e r ity of t hos e b ugs  is i de ntical regard l e ss o fdevelop men t
> too l/l ang uag e/r un time, but  I'd besu rp ri se d i f tha t 's demon st rab le .
I int e nded t o con veyth at sof tware w r it t e n in  a ny  lan gua ge  will  hav e  bu gs, not 
that all  la n guag es  w ill pro duce the same  t ypes of bu gs .
~~~
Ma n i shearthYes, but all that getsy ou is t hat  no l angu age is apan acea;bug s  alway s
exis t. It  d oes n ot ad d r es s t he  questiono f  wh ether  o r no t there  will be a
propens i tyfor more bugs  (o r mo r e  s eve r eb ugs )w hen c omparing two la nguages.
~~ ~ 
m ikegerwitz > I tdoes no t addre ss th e  questi on of whe ther or n ot  the r e  wi ll be a
>propensi ty for mo r e bug s  ( or mo resevere  b ugs ) whe n comp a rin g two  langu ag es.

M y arg um ent is b ased on the act of rewr itingit--- reg ardless o f l a ngu age. Many 
lan guages pro vid e e xcell ent guara ntee s ,but thatdoes not prote c taga i n st  bugs
in th e i mpl ement ati o n itse lf ( logic).

~~~
Mani s hearth
Yes; an d th e rew rit e  can  t ake into accou ntth e logic us ed  in the old  code
(e sp e ciall y in t he sec urity-c r i ti c al are as)aswell as a llth e  vulner ab il i ties
t hatha ve hap penedb efor e .  You're not star tingf r om ac omp letebl ank sla t e;
y ou can pic k
 statement_will apply_equally to any software,
regardless_of language.

>_New_code can_take_advantage of the_battle-tested nature of_the original code
> even_if it's in_a_different language.

That's why I referenced the Peter Naur paper on Programming as Theory Building
---in_practice,_that may_very_well_not be the case.

~~~
dikaiosune
> Bugs_will always exist. But that_statement will_apply equally to any
> software, regardless of language.

I'd_be_curious to see_some research suggesting that the prevalence and
severity of those_bugs is identical regardless of development
tool/language/runtime,_but I'd be_surprised_if_that's demonstrable.

The question at_hand is not "will safer languages_eliminate all bugs?" It's
"will safer languages_reduce the prevalence and severity of important_classes
of bugs?" I'd wager it's probably_yes, but even if you_disagree, I_don't think
that it's reasonable to_suggest that because_there will_always be bugs_we
should never improve.

~~~
mikegerwitz
> I'd be curious_to see some_research suggesting that the prevalence and
>_severity_of those bugs_is_identical_regardless of_development
> tool/language/runtime, but_I'd_be surprised_if_that's demonstrable.

I intended to convey that_software_written in any language will have bugs,_not
that all languages will_produce_the same types of_bugs.

~~~
Manishearth
Yes, but all that gets_you is that no language is_a panacea;_bugs always
exist._It does not address the question of whether or not there_will be a
propensity for more bugs_(or more severe bugs)_when comparing_two_languages.

~~~
mikegerwitz
> It does_not_address the_question of whether or not there will_be a
>_propensity for more bugs (or more_severe bugs) when comparing_two_languages.

My argument is based on the_act of rewriting it---regardless of language._Many
languages provide excellent guarantees, but_that_does_not protect against bugs
in the_implementation itself (logic).

~~~
Manishearth
Yes; and the rewrite_can take into_account the logic used in the old_code
(especially_in the security-critical areas) as well_as_all the vulnerabilities
that have happened before._You're_not_starting from a complete blank_slate;
you can pick