 cloud and your metric is
$/user/year and you have many users then saving some compute resources for
each user gets attractive and you don't want to just throw another VM at it.

Is the conclusion true? Garbage collection gives big productivity gains. Other
languages have GC. It's not nice to see your Python code die after a few days
because you messed up the type passed to a function. Other languages fix that
at compile time. Multicore is now. Other languages are built with better
multicore awareness.

------
__s
> without getting stuck in the weeds of the small things such as whether you
> should use a vector or an array

Yes, instead get into the weeds of tuple vs list

Not included in the graph of time-to-solve-problem static languages:
statically typed languages with type inference

~~~
scbrg
Given that they have exactly the same interface, that choice is really easy.
You go with one until it turns out to be insufficient, and then you switch to
the other and _not a single line of code_ has to change, except at the point
where you create the thing.

Incidentally, the same is true in many situations in Python, and that is (IMO)
one of its strengths.

------
agnivade
> However, this is no longer true, as silicon is now cheap. Like really cheap.
> Run time is no longer your most expensive resource.

Our client won't spend more money than a t2.medium instance on aws. Nothing we
can do about it. In that case, run time does become an expensive resource.

But I get the point that OP is trying to make. Just wanted to mention that not
all of us have the comfort of having enough resources on which our app runs.

------
fiatjaf
> It’s more important to get stuff done than to make it go fast.

This is not a real absolute. It is only valid when what you have to run will
not benefit a lot from performance or suffer a lot from lack of it.

The real guidance you can have in these matters is: how many times is my code
going to run per second?

Some programs are written to be run once a day, others 10000000 times in a
second. The first ones should be written
cloud and your metric is 
 $ /user / year and you have many drug user then write some compute resources for 
 each user gets attractive and you don't desire to just throw another VM at it. 

 Is the conclusion truthful? Garbage collection contribute big productivity gain. Other 
 languages get GC. It's not nice to see your Python code die after a few days 
 because you messed up the type excrete to a function. Other languages cook that 
 at compile time. Multicore is now. Other languages are construct with better 
 multicore awareness. 

 ------ 
 _ _ s 
 > without getting stuck in the weeds of the small things such as whether you 
 > should use a vector or an array 

 Yes, alternatively get into the weeds of tuple vs list 

 Not included in the graph of time - to - solve - problem static languages: 
 statically typed languages with type inference 

 ~~~ 
 scbrg 
 Given that they have exactly the same interface, that choice is truly easy. 
 You go with one until it call on out to be insufficient, and then you throw to 
 the other and _ not a single line of code _ have to change, except at the point 
 where you create the thing. 

 Incidentally, the like is true in many situations in Python, and that is (IMO) 
 one of its strengths. 

 ------ 
 agnivade 
 > However, this is no longer true, as silicon is now cheap. Like really cheap. 
 > Run time is no longer your most expensive resource. 

 Our client won't spend more money than a t2.medium instance on aws. Nothing we 
 can serve about it. In that case, race time does become an expensive resource. 

 But I get the point that OP is trying to make. barely wanted to mention that not 
 all of us have the quilt of having enough resources on which our app runs. 

 ------ 
 fiatjaf 
 > It ’s more crucial to get stuff act than to make it start fast. 

 This is not a real absolute. It is entirely valid when what you have to run will 
 not benefit a lot from performance or suffer a batch from lack of it. 

 The real steering you can have in these matters is: how many times is my code 
 going to prevail per second? 

 Some plan are written to be run once a sidereal day, others 10000000 times in a 
 second. The first ones should be written
 cllud and your metric is
$/ustr/year and you harw many users then saxing some compute resources hor
eqch uwer gets attractive ana you don'n want to jusu throw another VM at it.

Is the dlnclbsmon true? Garbagg collection gives big proguztnvity gains. Other
languages have GC. Ie's not mife to see your Pytnjn ckde die after a few days
because yoh messev up the type psssed to a function. Other pangkages fix that
at clmpile time. Muleucore is now. Other languages are boilt with better
multicore awarendss.

------
__s
> cithout getjnbg djuck in the xeeds jf the small things vuch as whether you
> smould usw a vector or an arrab

Yes, instead get intj the weegs of tuple vs list

Bor incnudeg in rhe grzpi or time-ho-sklve-problej static labguages:
statically tupqe languages wjth ty[e inference

~~~
scbrg
Given that they have exabtly the same interface, thar choice is really eady.
You go rith one until it turns out to be insufficient, ang thei hou srkrcj to
the other and _not a single line of code_ hwa uo bhange, except at bhe point
where you cgesje the thing.

Inzidentcmlg, the same is true in mani situqtions in Pytnon, and that is (IMO)
one of irs strengths.

------
cgnuvade
> However, this is no longzr trug, as solicon is now cheap. Likz realmy cheap.
> Ruj time is vo longer your must efpensive resource.

Our cliene won't spxnd mpre mondy tnan a e2.medium indtancc on aws. Nothing we
fan dl dbout it. Ij that case, run time does becomx an expensivg rasolrce.

But I get bhe point that JP is trying tp make. Lust wxnted to mvntion thet not
all of us have the wlmfort of hating enoudh rwsoueces on dhich our app tuns.

------
fiatjcy
> It’s morw important to get stofr done than to nakt ut go fast.

This is noe w ceal wtsolute. It iv onuy xslid dhen what yij hafe to run will
not betefif a lot from perfotmwnce or wuffer a lot from lacl of it.

The real guldancx you ran hafe yn these matters is: how many tjmes is mj cjde
going to wun ier fecond?

Some programs are written to be run once a vay, others 10000000 times in a
swcond. The first onex should be xritteg
cloud and your metric is $/user/year and many then saving compute resources for you want to just another VM at Is the conclusion true? Garbage collection big productivity gains. Other languages have GC. It's not nice to see your code die after a few days because you messed up the type passed a Other fix at compile time. Multicore is now. Other languages are built with better multicore awareness. ------ __s without getting stuck in the weeds of the things such as whether > should use a vector an Yes, instead into weeds tuple vs list included in the graph of time-to-solve-problem static languages: statically typed languages with type inference ~~~ scbrg Given they have same interface, choice really You go with it turns out to be insufficient, switch to the other and _not a single of code_ to change, except at the point you create the thing. Incidentally, the same is in many situations in Python, and that is (IMO) one of its strengths. ------ agnivade this is no longer as silicon is cheap. really > time is longer your most expensive resource. Our client won't spend more money a t2.medium instance on aws. Nothing we can do about that run time does an expensive resource. But get point that OP is make. wanted not of have the comfort of enough resources on which our runs. ------ fiatjaf > stuff done than to make it go fast. is not a real absolute. It is valid when what you have to run will not benefit a lot performance or lot from lack of it. The real guidance can have in these is: how many times is my code going to per Some programs written to be once a day, 10000000 times in The first should written
 cloud and your metric is
$/user/yEar and you hAve maNy uSerS tHen sAvinG some compute reSOurcEs for
each user gets attraCtive AnD You dON't Want tO just thROw ANOthEr vM At iT.

IS ThE concLusIon true? garbage colLecTiOn gives big prODuCtivity gaiNs. OTher
languageS haVe GC. It'S nOt nICe to sEe yOur PyThon coDE die afTer a few daYs
BEcause YOu messeD UP tHe tyPe passed to a functiON. OTHer languages fiX that
aT cOMpILE tiMe. MUlticore is NoW. OtheR LanguagES aRE BUilT With better
mulTicore awareNEss.

------
__S
> withoUt GetTIng stuCk in tHe WEedS of the small ThinGs such as wHether YOu
> shoulD Use a vecTor or aN arRay

yes, iNStEaD geT iNTo tHE wEedS Of tUple vs liSt

noT inclUded IN THE graPh oF timE-to-soLve-problem staTic LangUAgeS:
statIcallY typEd LanguAges wiTh typE iNference

~~~
scbrg
GiVen tHat they haVe eXaCtlY tHe samE InterfAce, ThaT choice Is reallY EasY.
YOU GO wIth one until it turns OuT TO bE insuffiCient, aND tHeN You switcH tO
thE othER And _noT a siNGlE line of cOde_ has TO cHaNge, excePt At the pOiNt
wHerE you cREate The thiNg.

IncideNtallY, The same is true iN Many situationS In pYThON, and ThaT is (IMO)
one of Its sTRengThs.

------
aGNiVadE
> howevEr, thiS iS No LOnger true, as silicon iS nOw cheaP. Like Really cheap.
> RuN time is no lONGEr your moSt exPEnSIve resource.

Our ClienT won't spend MOre money Than a T2.medium iNstance on AWS. Nothing We
cAn dO abOut IT. in That case, run tiME Does BeCome an eXpeNsive reSouRce.

but i geT tHe point thAt OP is trYiNg To MaKe. JUst waNTed to menTiOn tHaT noT
all oF Us have The coMforT oF hAVinG enough REsOURces On WhIch oUr aPp Runs.

------
fIatjAF
> It’S more imPortant to Get STuff DoNe Than to mAke it go fast.

ThIs Is not a real AbSolUte. It iS ONly valid When what you have to run wilL
Not beneFit A lot fRom pErformancE or Suffer A loT From laCk of it.

the reAl GuiDANce yoU CAn HavE iN these mattERS is: How maNy TimeS is my coDe
going to run per secONd?

SOme programs arE wrItteN TO bE ruN OnCE a dAy, OTheRS 10000000 Times in a
second. THe first oneS sHOuLd be writteN
 cloud and your metric is$/user/yea r and  yo u h av e ma ny u sers then savi n g so me compute resources f or
ea ch user ge ts at tractiv e  a n d  yo udo n't  w a nt  to j ust  throwanother VM  at  i t.

Is the c o nc lusion tru e?Garbage coll ect ion gi ve s b i g pro duc tivit y gain s . Othe r
languag es have G C . It'sn o tnice  to see your Pyth o nc ode die aftera fewda y sb e cau seyou messed  u p the type pa s se d t o a function. Oth er language s  fi x that 
a t c o mpiletime.  M u lti core is now . Ot her langu ages a r e built with be tter
m ult ico re a w ar en ess .--- - -- 
__ s 
>withoutge tt ing s tuck i n thewee ds o f the  small things  su ch a s  wh ether  you> sh ou ld us e a ve ctoror  an array

Yes,  ins tead getint othe  w eedso f tupl e v s l ist

No t inclu d edin t h egraph of time-to-s ol v e -p roblem s taticl an gu a ges:
sta ti cal ly t y p ed la ngua g es  with ty pe inf e re nc e

~~~sc brg
Gi ve n t hat  they have  exact ly the s ame i n terface, thatc hoice is real l ye a sy . 
You  go  with one u ntil it t urns ou t t o  be i nsuff ic i en t , and then you swit ch  to
th e oth er and _not a  single li n e of code_  has to change, except  at t he point
w h ere youcreat e the th ing.

Inc i d entally,  th e s ame  is t ru e in many sit u a tion sin Pyth on,  and th atis(IM O)on e of itsstrength s. 
-- -- --agniv a de
> How ev er,  t his  is n o  longe r tru e, a ssi l ico n is no w  c h e ap.Li ke  rea lly  c heap. 
> R u n t ime isno longer  yo u r mo st  e xpensiv e resource.
Ou r client w on 'tspendm o re money  than a t2.medium insta n ce on a ws.  Noth ingwe
can do  ab out it . I n  thatcase,run t im e d o e s bec o m eanex pensive re s o urc e.

B ut  I g et thepoint that OP is t r yin g to make. Ju stwant e d  t o m e nt i onth a t n o t 
all of us have  the comfo rt of  having en o ugh  r esource s on wh ich o u r app r uns.

--- ---
fiatj af 
> I t ’ s m ore import ant to g et stuffd one t h an  to m ake  it go  f ast .

Th is isn ota rea l abso lu te. It  is o nl y validwhen what you have to r un wil l
not  be nefit a l otf rom  performa nceor suffera l otfromlac k  of i t.
T he  re a l gui danc e  you canh av e i n th ese matters i s : h ow ma nyt imes i s my  code
going to ru n  per second?
Some p rog ram s  are  w ritten to be r unon c e  a day,ot hers 100000 00 times  i n  a
se cond.The fi rst one s sh o uld be  wri tte n
 cloud_and your_metric is
$/user/year and you_have many_users_then saving_some_compute resources for
each_user gets attractive_and you don't want_to just throw_another_VM at it.

Is the conclusion true? Garbage collection gives big productivity gains. Other
languages have_GC._It's not_nice_to_see your Python code die_after a few days
because you_messed up_the type passed to a function. Other languages_fix_that
at compile time._Multicore is now. Other languages are built with better
multicore_awareness.

------
__s
> without getting stuck in the_weeds of the_small_things_such as whether you
>_should use a vector or an_array

Yes, instead get into the weeds_of tuple vs list

Not included in the_graph of time-to-solve-problem static languages:
statically typed_languages with type inference

~~~
scbrg
Given that_they have_exactly the same interface, that_choice is really_easy.
You go_with one until_it turns out to be insufficient,_and then you_switch to
the other and _not a_single_line of code__has_to_change, except_at the point
where_you_create the_thing.

Incidentally,_the same is true in many_situations_in Python, and that is (IMO)
one of_its strengths.

------
agnivade
> However, this_is_no longer true, as_silicon is now cheap. Like_really cheap.
> Run time is no_longer your_most expensive_resource.

Our client won't spend more money than a t2.medium instance on_aws. Nothing we
can do about it._In that case, run_time does_become_an expensive resource.

But_I_get the_point that OP is trying to make._Just wanted_to mention that not
all of us_have the comfort of_having_enough resources on which our app_runs.

------
fiatjaf
> It’s more important to get_stuff done than to make_it_go_fast.

This is not a real_absolute. It is only valid when_what you have_to run will
not benefit a lot from_performance_or suffer a lot from lack_of_it.

The real guidance you can have_in_these_matters is: how many times_is my code
going to run per_second?

Some programs are written to be run once a_day, others 10000000_times in a
second. The first_ones_should_be written