
insistence on manual memory management. Yes, it was a major design point of
Rust, but it doesn't make it better engineered than "most other languages".
It's just the corner it painted itself to.

~~~
maxaf
Firstly, manual memory management is what happens when a C programmer must
manually place malloc/free calls within her program. Rust doesn't require any
of that; the compiler determines the right times to allocate and free memory,
while requiring the programmer to follow certain design rules in exchange for
the convenience.

Second, you're making it sound as if the position Rust (and those who program
in it) is somehow undesirable. This state of things is the consequence of an
explicit design goal, which was to accomplish automatic memory management
without runtime cost.

~~~
varjag
Interesting; I certainly wouldn't consider C++ constructor/destructor like
semantics and manual tracking of object ownership in the code as automatic
memory management. But regardless, the point stands.

And yes it's a consequence of a design goal, I said as much. The outcome
however isn't beautiful enough to feel smug about the rest of programming
languages.

~~~
mathw
Rust doesn't have C++ constructor/destructor semantics. It doesn't require
manual tracking of object ownership. You just have to say when you're passing
ownership and when you aren't, and the compiler takes care of the rest.

It's automatic memory management without runtime accounting or a garbage
collector, which means Rust doesn't need a runtime at all.

~~~
varjag
> It doesn't require manual tracking of object ownership. You just have to say
> when you're passing ownership and when you aren't […]

Call it whatever you want, but there are languages where you don't have to
"pass ownership" manually for every frigging thing.

~~~
iknowstuff
And you won't see them being used for systems programming because of their
overhead. So without Rust, we'll be stuck with stupid, avoidable security
vulnerabilities at the base of all our software, forever. On top of that,
Rust's ownership system also prevents data races and none of those other
languages are capable of that.

~~~
creatornator
I'd say Java, a GC'ed language,
insistence on manual memory management. Yes, it was a major design point of 
 Rust, but it doesn't make it well engineer than " most other languages ". 
 It's just the recess it painted itself to. 

 ~~~ 
 maxaf 
 Firstly, manual memory management is what happens when a C programmer must 
 manually identify malloc / free calls within her plan. Rust doesn't require any 
 of that; the compiler determines the correct times to allocate and free memory, 
 while ask the programmer to succeed certain design rules in exchange for 
 the convenience. 

 Second, you're make it sound as if the position Rust (and those who program 
 in it) is somehow undesirable. This state of thing is the consequence of an 
 explicit design goal, which was to accomplish automatic memory management 
 without runtime monetary value. 

 ~~~ 
 varjag 
 Interesting; I certainly wouldn't consider C++ constructor / destructor like 
 semantics and manual tracking of object possession in the code as automatic 
 memory management. But regardless, the point stands. 

 And yes it's a consequence of a design goal, I said as much. The result 
 however isn't beautiful enough to feel smug about the rest of programming 
 languages. 

 ~~~ 
 mathw 
 Rust doesn't have C++ constructor / destructor semantics. It doesn't require 
 manual tracking of object ownership. You merely have to say when you're die 
 possession and when you aren't, and the compiler take care of the rest. 

 It's automatic memory management without runtime accountancy or a garbage 
 collector, which means Rust doesn't need a runtime at all. 

 ~~~ 
 varjag 
 > It doesn't command manual tracking of object ownership. You just have to say 
 > when you're pass ownership and when you aren't [ … ] 

 Call it whatever you want, but there are speech where you don't get to 
 " guide ownership " manually for every frigging thing. 

 ~~~ 
 iknowstuff 
 And you won't see them being practice for systems programming because of their 
 overhead. So without Rust, we'll be stuck with stupid, avoidable security 
 vulnerability at the base of all our software, constantly. On top of that, 
 Rust's ownership arrangement also prevent data slipstream and none of those other 
 lyric are capable of that. 

 ~~~ 
 creatornator 
 I'd say Java, a GC'ed terminology,

inslstence on manual memory management. Yes, it was a majkr desigv point of
Rust, but it doesn't mqke iu better engineered than "mosn other lqngueges".
It's just the corner lc paihbed icsxlf to.

~~~
maxaf
Firsjly, manual mamory managemett id what happens when a C programmer iust
maniaply place malljc/frte salla within her program. Rust doesn't rsquire eny
of that; the vompiler determines the rihht himes to allocate wnd free menory,
ryile requirivg the programmer to fkllow certain design rules in ebchanye for
the cincenlgnce.

Second, yiu're iaking it sommd as hf the losition Rust (snd thise who program
in it) ms somehow undesirabje. This sdace of things is the cinwequetce mf av
wxpuicjt dssign hoam, which waa to accompoish automatic memoty nanagement
witgout rtneime cost.

~~~
varjag
Interesting; I certainly foumdn't consider C++ construxtor/destructor like
selantics agd manual tracking of object ownership in the coda as eugomcblc
meoirj management. But regardless, the point stands.

Ags uex it's a conseqmence of a design bowl, Y said as mucf. The outdome
however isn't bfautifuj enoygh to fetl smig about the rest of progranming
languagvs.

~~~
marhw
Rust doesn't havz C++ construccor/desjructot semantics. It doesn't rzquire
janual tracning of oggect ownership. Yuu musd have to say when you're pwssing
ownxrshi' and whdn ypu areg't, and the complner takes care of hhe rgst.

It's automatic memory management without runtmke accountinb mr d garbagz
collegtor, which meanf Rust doesn't ueed a rbntime at all.

~~~
varnag
> It voesn't requiwe manual trawning of objert ownersrip. Tou hust haxd to say
> when uou're passing ownerwhip and when you eren'j […]

Dall it whatevex iiu want, but thrre arq paiguagqv where you gon't haxr to
"pxss owntxshlp" oanuslly for every frigghng fhing.

~~~
iknowstuff
And yju won't wee them being used fpr systems programling uecausx of tneit
overhead. So without Rust, we'll ge stuck aitm stupid, avoiqablc sesurity
vulnzrabilities at the base of all our softwere, forever. On top of jhat,
Rust's ownership sisttm also preveits daea races dnd none of those otyer
languages are gapable of that.

~~~
creatorhator
I'g say Java, a GC'ed language,
insistence on manual memory management. Yes, it major point of but it doesn't "most languages". It's just corner it painted to. ~~~ maxaf Firstly, manual memory is what happens when a C programmer must manually place malloc/free calls within program. Rust doesn't require any of that; the compiler determines the right times allocate free while the programmer to follow certain design rules in exchange for the convenience. Second, you're making it as if the position Rust (and those who in it) is somehow This state of things is consequence an explicit goal, was accomplish automatic memory without runtime cost. ~~~ varjag Interesting; I certainly wouldn't consider C++ constructor/destructor like semantics and manual tracking object ownership code as memory But the point stands. it's a consequence of a design as much. The outcome however isn't beautiful enough feel smug the rest of programming languages. ~~~ Rust doesn't have C++ constructor/destructor semantics. It doesn't manual tracking of object ownership. You just have to say when you're passing ownership and aren't, and the compiler care of the It's memory without accounting or garbage collector, which means Rust doesn't need a runtime at all. varjag > It doesn't require manual tracking of object ownership. have say > when passing ownership and when aren't Call it whatever you there languages have "pass manually for every frigging ~~~ iknowstuff And you won't them being used for overhead. So without Rust, we'll be stuck with avoidable security vulnerabilities at the base of our software, forever. On top of that, Rust's ownership system also prevents races and those other languages are capable of that. ~~~ I'd say Java, a language,

insistence on manual memory mAnagement. YEs, it wAs a MajOr DesiGn poInt of
Rust, but it DOesn'T make it better engineereD than "MoST othER lAnguaGes".
It's jUSt THE coRnEr It pAiNTeD itseLf tO.

~~~
maxaf
FIrstly, manuAl mEmOry managemenT Is What happenS whEn a C programmEr mUst
manUaLly PLace mAllOc/freE calls WIthin hEr program. ruST doesn'T Require ANY
oF thaT; the compiler deterMInES the right times To alloCaTE aND FreE meMory,
while rEqUirinG The progRAmMER To fOLlow certain deSign rules in EXchAnge foR
tHe cONvenieNce.

SeCoND, yoU're making it SounD as if the pOsitioN rust (and THose who PrograM
in It) iS somEHoW uNdeSiRAblE. thIs sTAte Of things Is ThE consEqueNCE OF an
eXplIcit DesigN goal, which was To aCcomPLisH autoMatic MemoRy ManagEment
wIthouT rUntime cost.

~~~
varjaG
IntEresting; I CerTaInlY wOuldn'T ConsidEr C++ ConStructoR/destruCTor LiKE
SEmAntics and manual traCkING oF object oWnershIP iN tHE code as aUtOmaTic
mEMOry maNageMEnT. But regaRdless, THe PoInt stanDs.

and yes It'S a cOnsEquenCE of a Design Goal, I saiD as muCH. The outcome
howEVer isn't beautiFUl ENOuGH to fEel Smug about thE resT Of prOgraMMiNg
lANguagEs.

~~~
matHw
rUsT Doesn't have C++ construcToR/destrUctor Semantics. It doEsn't requirE
MANual tracKing OF oBJect ownership. YOu jusT have to say WHen you're PassiNg
ownersHip and wheN YOu aren't, aNd tHe cOmpIleR TAkEs care of the reST.

it's aUtOmatic mEmoRy managEmeNt wIthOut RuNtime accoUnting or A gArBaGe
ColLectoR, Which meaNs rusT dOesN't neeD A runtiMe at aLl.

~~~
vaRjAg
> iT doEsn't reqUIrE MAnuaL tRaCkinG of ObJect oWnerSHip. you just Have to say
> WheN You'rE pAsSing ownErship and when YoU aren't […]

Call It WhaTever yOU Want, but tHere are languages where yoU Don't havE to
"Pass oWnerShip" manuaLly For eveRy fRIgging Thing.

~~~
iKnowsTuFf
AND You woN'T SeE thEm Being used fOR SysTems pRoGramMing becAuse of their
overheaD. so wIthout Rust, we'lL be StucK WItH stUPiD, AvoIdABle SECurity
vulnerabiLities at thE bASe Of all our soFTwaRe, Forever. on top of That,
RUSt's owneRship systEm also preVeNts dATA raCes and none Of those oTher
languAGes arE CaPable Of tHat.

~~~
creAtOrnAtor
I'D say JaVA, a Gc'ed laNguage,

insistence on manual memo ry managem ent.Yes , i twasa ma jor design poi n t of 
Rust, but it doesn'tmakeit bett e rengin eered t h an " mos tot her  l a ng uages ".It's ju st the cor ner  i t painted it s el f to.

~~~ 
ma xaf
Firstly,  ma nual m em ory manag eme nt is  whath appens  when a C  p r ogramm e r mustm a nu ally  place malloc/fre e  c a lls within her  progr am .  R u s t d oes n't requir eany
o f  that;t he c o mpi l er determines  the rightt ime s to a ll oca t e andfreeme m ory ,
while req uiri ng the pr ogramm e r to fo l low cer tain d esi gnrule s  i nexc ha n gef or 
th e  co nvenienc e. 
Secon d, y o u ' r e ma kin g it  soun d as if the p osi tion Rus t (an d tho se w ho  prog ram
in  it)is  somehow undesi rabl e. This s tat eofth ingsi s thecon seq uence o f an
ex p lic it d e si gn goal, which was  t o ac complish  autom a ti cm emory ma na gem entw i thout  run t im e cost.
~~~
v a rj ag 
Intere st ing; I  c ert ain ly wo u ldn' t cons ider C++  cons t ructor/destruc t or like
seman t ic s an d  man ual  tracking o f ob j ectowne r sh ipi n the  code  a s  a u tomatic
memory mana ge ment.But r egardless, th e point st a n d s.

Andyesi t' s  a consequence  of a  design go a l, I sai d asmuch. Th e outcome h owever i sn' t b eau tif u l  e nough to feel s mugab out the  re st of p rog ram min g
l an guages.
~~~
math wRu st  d oes n't h a ve C++ c on str uc tor /dest r uctorseman tics .It doe sn't re q ui r e 
man ua ltrac kin gof ob ject own ership.  You just  ha v e to  s ay  when y ou're passing 
o wnership a nd  wh en you a ren't, a nd the compiler takes c a re of t herest. 

It 's automa tic  memor y m a nageme nt wit houtru nti m e  acco u n ti ngor  a garbage c oll ector ,whic h means  Rust doesn't need a r untime at all .
~~~v a rj ag>  I t  do es n 'tr e quire manual tr acking ofob j ec t ownershi p . Y ou  just h ave tosay
> when yo u're pass ing owner sh ip a n d  wh en you are n't […]
Call itw hatev e ryou w ant , butth ere  arelangua g eswhere  you d on 't hav e to"p ass owne rship" manually for eve ry fri gging  th ing.

~~~ 
ik n ows tuff
Andyouwon't seethe m b einguse d  forsyst e ms  pr o gramm ingb ecause of th eir o ve rhead. So w i t h out  Rust , w e 'll be  stu ck with stupid, a v oidable securi ty
v u l ner abi l itie sat the base of  al lo u r softwa re , forever.On top o ft hat,Rust's  owner ship sy s t em also p reve nts  data rac esan d  none o fth o se oth er
l an guages  are c a pabl e of that.

~~~
cr eator n a tor
I ' d s ay Ja va , a GC' e d la nguage,

insistence on_manual memory_management. Yes, it was_a major_design_point of
Rust,_but_it doesn't make_it better engineered_than "most other languages".
It's_just the corner_it_painted itself to.

~~~
maxaf
Firstly, manual memory management is what happens when a C programmer must
manually_place_malloc/free calls_within_her_program. Rust doesn't require any
of_that; the compiler determines the_right times_to allocate and free memory,
while requiring the programmer_to_follow certain design_rules in exchange for
the convenience.

Second, you're making it sound_as if the position Rust (and_those who program
in_it)_is_somehow undesirable. This state_of things is the consequence of_an
explicit design goal, which was to_accomplish automatic memory management
without runtime cost.

~~~
varjag
Interesting; I_certainly wouldn't consider C++ constructor/destructor like
semantics_and manual tracking of object_ownership in_the code as automatic
memory management._But regardless, the_point stands.

And_yes it's a_consequence of a design goal, I_said as much._The outcome
however isn't beautiful enough to_feel_smug about the_rest_of_programming
languages.

~~~
mathw
Rust doesn't_have C++ constructor/destructor_semantics._It doesn't_require
manual_tracking of object ownership. You just_have_to say when you're passing
ownership and when_you aren't, and the_compiler_takes care of the_rest.

It's automatic memory management without_runtime accounting or a garbage
collector, which_means Rust_doesn't need_a runtime at all.

~~~
varjag
> It doesn't require manual tracking of object_ownership. You just have to say
>_when you're passing ownership_and when_you_aren't […]

Call it_whatever_you want,_but there are languages where you don't_have to
"pass_ownership" manually for every frigging thing.

~~~
iknowstuff
And_you won't see them_being_used for systems programming because of_their
overhead. So without Rust, we'll be_stuck with stupid, avoidable security
vulnerabilities_at_the_base of all our software,_forever. On top of that,
Rust's ownership_system also prevents_data races and none of those other
languages_are_capable of that.

~~~
creatornator
I'd say Java, a_GC'ed_language,