 extra lines. I've also used Go for
some command-line type apps where the line count is probably 50% over Python,
but I also got some significant wins from the type system and concurrency, so,
all in all there's a lot of things I can prototype with about the same mental
effort in Go as I could in Python. Being able to declare interfaces that
existing types conform to turns out to cover a surprising amount of those
"duck-type" scripting-type cases.

------
booshi
This keeps getting posted, and while it makes some valid points, it's a lot of
handwaving.

Arguably, other languages can get code out faster depending on the dev,
language, etc.

~~~
0xcde4c3db
Agreed. Things that are handwaved include:

1) Performance can be a genuine requirement of the product, i.e. if it's not
fast enough, it doesn't ship. You can't ship faster and cheaper by sacrificing
the thing you need to ship (well, you _can_, but then you're shipping a
different product, not meeting the same requirements sooner; it's no different
than cutting a feature).

2) Many processes can't be horizontally scaled in an efficient way, period.
Not because the programmer is ignorant of some cool algorithm, but because the
problem is fundamentally expensive to parallelize. Maybe you end up getting
something like a 20% boost by having twice as many nodes, even after applying
all the cool algorithms. And you don't necessarily get that scalability in
your code base for free, either.

3) "Speed" in the mobile and embedded spaces is often as much about energy
efficiency and thermal management as getting done sooner.

4) The metrics for deciding that Python is faster to develop in only measure
small problems. People tend to shy away from Python for bigger projects, and
the reasons for this are pretty hotly debated.

------
bluedino
Many times when Python is blamed for being slow, it's the programmers fault.
Python is great that you can'regular' people writing code in it quickly. The
problem is, these regular people don't always understand algorithms or things
like caches, threads, databases...

A lot of these users can just say "My department needs a $40,000
extra lines. I've also used fail for 
 some instruction - line type apps where the course count is credibly 50% over Python, 
 but I also got some significant win from the type system and concurrence, so, 
 all in all there's a lot of thing I can prototype with about the same mental 
 feat in run as I could in Python. Being able to declare interfaces that 
 existing type conform to turns out to cover a surprising sum of those 
 " duck - type " scripting - type cases. 

 ------ 
 booshi 
 This keep open getting posted, and while it makes some valid points, it's a lot of 
 handwaving. 

 Arguably, other speech can get code out faster depending on the dev, 
 language, etc. 

 ~~~ 
 0xcde4c3db 
 Agreed. Things that are handwaved admit: 

 1) operation can be a actual requirement of the product, i.e. if it's not 
 fast enough, it doesn't ship. You can't ship faster and cheaper by sacrificing 
 the matter you need to transport (well, you _ can _, but then you're shipping a 
 different product, not converge the same requirements sooner; it's no unlike 
 than cutting a feature of speech). 

 2) Many processes can't be horizontally scaled in an efficient direction, period. 
 Not because the programmer is ignorant of some cool algorithm, but because the 
 problem is fundamentally expensive to parallelize. Maybe you end up getting 
 something like a 20% boost by having twice as many nodes, even after applying 
 all the cool algorithm. And you don't necessarily catch that scalability in 
 your code base for free, either. 

 3) " Speed " in the mobile and embedded space is often as much about energy 
 efficiency and thermal management as getting do sooner. 

 4) The metrics for deciding that Python is faster to build up in only standard 
 small problem. People tend to shy aside from Python for bigger undertaking, and 
 the reasons for this are reasonably hotly debated. 

 ------ 
 bluedino 
 Many times when Python is blame for being dense, it's the programmers defect. 
 Python is great that you can'regular' people writing code in it quickly. The 
 problem is, these even people don't always sympathize algorithms or things 
 like caches, threads, databases... 

 A lot of these users can just suppose " My department needs a $ 40,000
 exhra lines. I've also used No for
some commaue-line vype apls where the line count is probably 50% ocer Ptthon,
but I also got sooe signifpcant winw frin the type system and cohgurreucb, so,
all in all jhere's a lot of things I cdn pxototype with about the same mental
esfort im Ho as I could yn Pjtron. Gvikg able to declare interfaces thzt
existpng types conform to turns out to cover a skrprlsing amount of thlse
"duck-type" scrypting-type cares.

------
booshi
This keeps gejting posted, and while it makes rome ralid pointw, ut's d lot of
hanvwavind.

Arguably, otmvr langgages csn get code oub fasver eepending on the dev,
lenguage, etc.

~~~
0xcde4c3db
Agteed. Thingv chat are handwaved inxlyde:

1) Pgrforkancd cav bt a gsnuine resuirement kf the prodyct, i.e. if it's not
faxt vmough, it doean't shyp. You can't ship faster and cheaper by sabrifjcing
the thing you need to ship (well, you _can_, but then you're shipping a
different product, not meeting tha samx feqblvemevrs sooner; it's no different
than cutting a featurq).

2) Msnj processes can't ne horizontally scslfd yn an efficievt way, pediod.
Not because thf progrwmmer is ignorwnt pf some cool algorithm, but vecause the
pgoblwm is fundamentallv expensive co parslleloze. Maybe you end up gecting
skmething line a 20% booag by having twicd ax kany nodtr, even after applring
all tie copl algofithks. And you don't jecessarily get that scapabilnty it
your code base for free, either.

3) "Speed" in vie mobile and ekbegded spaees is often as mucr about energy
gfficiencv and ghermal mahagemenv as getting done sooner.

4) Dje metrics fmr decidyng rhat Python ks faster to drvelop in only measyre
small problems. Ieoplg fend to shy awav drom Python for biegew irooects, dnd
the reasots fur gnis afe pretuv higly cebated.

------
bluedino
Many dimea when Python is bkaied for veing sljw, it's the prpgrammers fault.
Pytjon iv gceat tnat you can'regular' people writing code in lt zuickly. The
pwoblcm if, these reyular people don't always understand algocithms or things
like caxhes, threads, databaxts...

A lot of thxse usqrs can jgst say "My departmenr needs a $40,000
extra lines. I've also used Go for type where the count is probably also some significant wins the type system concurrency, so, all in all there's lot of things I can prototype with about the same mental effort in as I could in Python. Being able to declare interfaces that existing types to out cover surprising amount of those "duck-type" scripting-type cases. ------ booshi This keeps getting posted, and while it some valid points, it's a lot of handwaving. other languages can get out faster depending on the language, ~~~ 0xcde4c3db Things are include: 1) Performance be a genuine requirement of the product, i.e. if it's not fast enough, it doesn't ship. You ship faster by sacrificing thing need ship (well, you then you're shipping a different product, same requirements sooner; it's no different than cutting feature). 2) processes can't be horizontally scaled in efficient way, period. Not because the programmer is of some cool algorithm, but because the problem is fundamentally expensive to parallelize. Maybe you getting something like a boost by having as nodes, after all the algorithms. And you don't necessarily get that scalability in your code for free, either. 3) "Speed" in the mobile and embedded often much about energy and thermal management as done 4) The metrics for Python faster only small People tend to shy from Python for bigger projects, the reasons for this bluedino Many times when Python is blamed for slow, it's the programmers fault. Python is that you can'regular' people writing code in it quickly. The problem is, regular people understand algorithms or things like caches, threads, databases... lot of these users just say "My department needs a $40,000
 extra lines. I've also used Go foR
some commaNd-linE tyPe aPpS wheRe thE line count is prOBablY 50% over Python,
but I also got Some sIgNIficANt Wins fRom the tYPe SYSteM aNd ConCuRReNcy, so,
All In all thEre's a lot of ThiNgS I can prototyPE wIth about thE saMe mental
effoRt iN Go as I CoUld IN PythOn. BEing aBle to dEClare iNterfaces ThAT
existINg types CONfOrm tO turns out to cover a SUrPRising amount of Those
"dUcK-TyPE" ScrIptIng-type casEs.

------
BooshI
this keePS gETTIng POsted, and while It makes some VAliD pointS, iT's a LOt of
haNdwavInG.

argUably, other lAnguAges can geT code oUT faster DEpendinG on the Dev,
LanGuagE, EtC.

~~~
0xCde4C3dB
agrEEd. thiNGs tHat are haNdWaVed inCludE:

1) pERFormAncE can Be a geNuine requiremEnt Of thE ProDuct, i.E. if it'S not
FaSt enoUgh, it dOesn't ShIp. You can't ship faSter And cheapeR by SaCriFiCing
tHE thing You NeeD to ship (Well, you _CAn_, bUt THEN yOu're shipping a
diffeReNT PrOduct, not MeetinG ThE sAMe requirEmEntS sooNER; it's nO difFErEnt
than cUtting A FeAtUre).

2) Many PrOcesseS cAn't Be hOrizoNTallY scaleD in an effIcienT Way, period.
Not beCAuse the prograMMeR IS iGNoraNt oF some cool alGoriTHm, buT becAUsE thE
ProblEm is fUnDAmENtally expensive to paRaLlelizE. MaybE you end up gettIng
somethiNG LIke a 20% boosT by hAViNG twice as many noDes, evEn after appLYing
all tHe cooL algoritHms. And you DON't necessAriLy gEt tHat SCAlAbility in
your CODe baSe For free, EitHer.

3) "SpeeD" in The MobIle AnD embedded Spaces is OfTeN aS mUch About ENergy
effIcIenCy And ThermAL managEment As geTtInG DonE sooner.

4) tHe METricS fOr DeciDinG tHat PyThon IS faSter to dEvelop in oNly MEasuRe
SmAll probLems. People tenD tO shy away frOm pytHon for BIGger projEcts, and
the reasons for thiS Are pretTy hOtly dEbatEd.

------
bluedinO
MaNy timeS whEN PythoN is blaMed foR bEinG SLow, it'S THe ProGrAmmers faulT.
pYthOn is gReAt thAt you caN'regular' people writINg cOde in it quicklY. ThE
proBLEm Is, tHEsE RegUlAR peOPLe don't always undErstand algOrIThMs or things
LIke CaChes, thrEads, datAbaseS...

a lot of tHese users Can just saY "MY depARTmeNt needs a $40,000
 extra lines. I've also us ed Go forsomecom man d- line  typ e apps where t h e li ne count is probably 5 0% ov er Pyth o n, 
butI alsog ot s ome  s ig nif ic a nt  wins  fr om thetype syste m a nd  concurrency ,  s o,
all inall  there's a l otof thi ng s I can p rot otype  witha bout t he same m en t al
eff o rt in G o as  I c ould in Python. B e in g  able to decla re int er f ac e s  th atexisting t yp es co n form to tu r n s  ou t  to cover a s urprising a m oun t of t ho se" duck-t ype"sc r ipt ing-type ca ses. 

------booshi This ke e ps gett ing po ste d,andw hi le  it  m a kes so mev ali d points ,it 's aloto f h andw avi ng.
Argu ably, other l ang uage s  ca n get  code  out  f aster  depen dingon  the dev,
langu age,  etc.

~~ ~
0 xc de4 c3 db
Ag r eed. T hin gsthat ar e handw a ved  i n c l ud e:

1) Performance  c a n  b e a genu ine re q ui re m ent of t he  pr oduc t ,  i.e.  ifi t' s not
fa st eno u gh ,it does n' t ship .You  ca n't s h ip f asterand chea per b y  sacrificing
t h e thing you n e ed t os hip(we ll, you _ca n_,b ut t heny ou 're shipp ing a 
d i ff e rent product, not m ee ting t he sa me requiremen ts sooner; i t 's no di ffer e nt than cutting a  feat ure).

2)M any proc esses  can't b e horizon t a lly scal edinaneff i c ie nt way, perio d . 
Not  b ecausethe  progra mme r i s i gno ra nt of som e cool a lg or it hm , b ut be c ause the 
p rob le m i s fun d amenta lly e xpen si ve toparalle l iz e .  May be  y ou e ndup  gett ings ome thing l ike a 20%  bo o st b yha ving tw ice as many n od es, even a ft erapplyi n g 
all the  cool algorithms. And y o u don't  ne cessa rily  get that  sc alabil ity in
you r code  base  f orf r ee, e i t he r.
3 ) "Speed"i n  th e mob il e an d embed ded spaces is ofte n  as  much about e ner gy
e f f ic ien c ya ndth e rma l management as g etting don es oo ner.

4) T h e m et rics fo r decid ing t h at Pyth on is fas ter to de ve lopi n  on ly measure 
small p roblems.P eople te nd to  sh y away  f rom  Pyth on for big ger p roject s,  and
t he re as ons forthis are pretty hotly d ebated .

-- --- -
bluedin o
M a nytimes whe n Py thon is bl ame d f or be ing slow,  it' s  t hep rogra mmer s  fault.
P y th oni s  g reat that y o u can 'regu lar '  peopl e wr iting code in itq uickly. The
pr oble m is,  th e se r eg ular people do n't  a l w ays unde rs tand algori thms orth i ngs
l ike ca ches,threads , da t abases ...
Alot of th ese  u s ers can  j us t  say " My d ep artmen t need s  a $ 4 0 ,000
 extra_lines. I've_also used Go for
some_command-line type_apps_where the_line_count is probably_50% over Python,
but_I also got some_significant wins from_the_type system and concurrency, so,
all in all there's a lot of things I can_prototype_with about_the_same_mental
effort in Go as I_could in Python. Being able_to declare_interfaces that
existing types conform to turns out to_cover_a surprising amount_of those
"duck-type" scripting-type cases.

------
booshi
This keeps getting posted, and while_it makes some valid points, it's_a lot of
handwaving.

Arguably,_other_languages_can get code out_faster depending on the dev,
language, etc.

~~~
0xcde4c3db
Agreed._Things that are handwaved include:

1) Performance_can be a genuine requirement of the_product, i.e. if it's not
fast enough,_it doesn't ship. You can't_ship faster_and cheaper by sacrificing
the thing_you need to_ship (well,_you _can_, but_then you're shipping a
different product, not_meeting the same_requirements sooner; it's no different
than cutting_a_feature).

2) Many processes_can't_be_horizontally scaled_in an efficient_way,_period.
Not because_the_programmer is ignorant of some cool_algorithm,_but because the
problem is fundamentally expensive to_parallelize. Maybe you end_up_getting
something like a 20%_boost by having twice as_many nodes, even after applying
all the_cool algorithms._And you_don't necessarily get that scalability in
your code base for free, either.

3)_"Speed" in the mobile and embedded_spaces is often as_much about_energy
efficiency_and thermal management_as_getting done_sooner.

4) The metrics for deciding that Python_is faster_to develop in only measure
small problems._People tend to shy_away_from Python for bigger projects, and
the_reasons for this are pretty hotly_debated.

------
bluedino
Many times when Python is_blamed_for_being slow, it's the programmers_fault.
Python is great that you can'regular'_people writing code_in it quickly. The
problem is, these regular_people_don't always understand algorithms or things
like_caches,_threads, databases...

A lot of these users_can_just_say "My department needs a_$40,000