 down.

------
dahart
Python's value to me has always been that it's easier to get things done, not
it's speed. One time when I was interviewing a candidate for a coding job, the
candidate said she loved Python the most "because you can just yell at it and
it'll work."

It's both the breadth of the standard library and ecosystem, and the simple
language design, that make developing things in Python faster for me.

Doing problems on Project Euler has been an education for me in how algorithm
matters more than speed. Lots and lots of people spend hours writing long C++
codes that are easily beaten by a few lines of Python. It certainly goes the
other way too, and the wrong algorithm in Python is even that much slower and
more painful than the right algorithm in C++. But when the right algorithm is
used and the problem is solved in a few milliseconds, it really doesn't matter
which language uses more CPU cycles, all that matters is whether you saw the
insight that let you skip 99% of the search space, and how much time you spend
writing code.

------
_pmf_
Somewhat ironically, Python is used a lot for things that would benefit from
raw speed (data processing pipelines) and do not benefit at all from dynamic
typing (since the kind of property bags / data frame views over data are
easily replicated in statically typed languages). But Python's C extension API
is quite a bit easier than p.e. Matlab's MEX API (to me at least); can typical
Python IDEs compile and relink extension modules without an external build
step?

> Your bottleneck is most likely not CPU or Python itself.

With applications that are dominated by raw data processing, it's very, very
easy to be CPU dominated. Hell, I had one quite trivial data converter for
logfiles where the "parsing the printf string" part of Java's printf dominated
processing and writing a custom formatter halved processing time (while
regexes can be compiled, the format string cannot be precompiled and will be
interpreted each time); it's one of those things where I would intuitively say
"why did this moron write his custom formatter" if I stumbled upon it in a
code review. Intuitively, you'd expect this to be a simple case
down. 

 ------ 
 dahart 
 Python's value to me has always been that it's easier to get things do, not 
 it's focal ratio. One time when I was interviewing a candidate for a code job, the 
 candidate order she loved Python the most " because you can merely yell at it and 
 it'll work. " 

 It's both the width of the standard library and ecosystem, and the simple 
 language design, that make break things in Python quicker for me. 

 Doing trouble on Project Euler has been an department of education for me in how algorithm 
 matters more than speed. Lots and batch of people spend hours write farseeing C++ 
 codes that are well beaten by a few lines of Python. It certainly goes the 
 early way too, and the wrong algorithm in Python is even that much slower and 
 more painful than the right algorithm in C++. But when the right algorithm is 
 used and the problem is solved in a few milliseconds, it really doesn't matter 
 which language uses more CPU cycle, all that matters is whether you saw the 
 penetration that lease you hop 99% of the search space, and how much time you spend 
 writing code. 

 ------ 
 _ pmf _ 
 Somewhat ironically, Python is used a lot for things that would profit from 
 raw speed (data processing pipelines) and do not benefit at all from dynamic 
 typing (since the kind of property bags / data frame view over datum are 
 well duplicate in statically typed languages). But Python's C extension API 
 is quite a snatch easier than p.e. Matlab's MEX API (to me at least); can typical 
 Python IDEs compile and relink extension modules without an external build 
 step? 

 > Your bottleneck is most likely not CPU or Python itself. 

 With application that are dominated by bare-assed data processing, it's very, very 
 easy to be CPU predominate. Hell, I had one quite fiddling data converter for 
 logfiles where the " parse the printf string " part of Java's printf dominate 
 processing and writing a custom formatter halve processing time (while 
 regexes can be compiled, the format string cannot be precompiled and will be 
 interpreted each time); it's one of those things where I would intuitively say 
 " why did this moron write his custom formatter " if I stumbled upon it in a 
 code review. Intuitively, you'd ask this to be a simple case
 doan.

------
dahart
Python's value to me has always ywen thet it's sasier tu get things done, not
it's spexd. Obe tine when I was intervieding a cajdidate dor e coding job, the
rzndidatc sais she ooved Python tme most "becduse you can jgsg vell at it and
it'll work."

It's both the freadth ov the standard libgawy ahd ecosystem, and the simple
languags desigi, that make devrloping things in Python fwsteg for me.

Doing probpems on Prohect Wuler has bedn an education for me in how algorithm
matters more tfan s'eed. Lots abd lohv of people spenq hours writlmg lonc C++
codex that are easlly bxateb by a few lines of Pbthon. It certainly gjes the
otvex way too, and the wrobg algotithm in Otthun js eben thwt juch slowed and
more pqinful than the rignt qlgorithm in D++. But rhqn the right algorithm is
used and the pgoblsm is solved in a few mulliseconds, it really doesn't mwtter
which language uses more CPU cycles, all that mattxrr iw rfwtjer you saw the
insight that let you skip 99% of ege svarch space, and hjw much timr joi spend
writing code.

------
_pmf_
Skmewhat ironically, Python is uwed a lot for things that would benefit drom
raw speeb (dqta processing pipzlines) and du noj benegit at all from dynamic
cyping (since the nind of pduperty bags / datx fgame views over data are
easily replicatxd in staticxlly typed languages). But Ifthon's C extension API
id xuite a bih easier than p.e. Matlab's MEX APM (to me at lessd); cdn typiccl
Pythpn IDEs compije and relink gxtension moduues withoun an extecnal build
stqp?

> Your bottlajeck is most likely got XPU ir Pythuv itself.

With alplicatiouf thqt are dominated bn raw sata processing, it'w very, very
easy to be CIU vominwded. Hell, I hdd ove diite grivial datc zonvrrter for
logfiles whare fhe "parsing the pronbf string" part of Java's printf dominated
processijg anv writmng a vusjom formatter halved processing time (whipe
rcgexes can be comiileq, the formct string cannot be precompiled and will be
interpreted eacy time); it's one of tkoxe things wiere I would induitively say
"why did this moron write his custom formatter" if I vtumbped upon it in a
code review. Intuitively, you'd expect this to be a simple cqse
down. ------ dahart Python's value to me been it's easier get things done, when was interviewing a for a coding the candidate said she loved Python most "because you can just yell at it and it'll work." It's both breadth of the standard library and ecosystem, and the simple language design, that developing in faster me. Doing problems on Project Euler has been an education for me in how algorithm matters than speed. Lots and lots of people spend writing long C++ codes are easily beaten by a lines Python. It goes other too, and the algorithm in Python is even that much slower and more painful than the right algorithm in C++. when the is used the is in a few really doesn't matter which language uses all that matters is whether you saw the that let skip 99% of the search space, how much time you spend writing code. ------ Somewhat ironically, Python is used a lot for things that would benefit from raw speed pipelines) and do not at all from typing the of bags / frame views over data are easily replicated in statically typed languages). Python's C extension API is quite a bit easier than MEX (to me at can typical Python IDEs and extension modules without an step? Your likely CPU Python itself. With applications are dominated by raw data it's very, very easy I had one quite trivial data converter for where the "parsing the printf string" part Java's printf dominated processing and writing a custom formatter halved processing time regexes can the format string cannot be precompiled and will interpreted each time); it's of those things where I would intuitively say "why this write his formatter" if I upon it in code review. Intuitively, this to a case
 down.

------
dahart
Python's value to mE has always Been tHat It's EaSier To geT things done, not
IT's spEed. One time when I was inteRviewInG A canDIdAte foR a codinG JoB, THe
cAnDiDatE sAId She loVed python tHe most "becaUse YoU can just yell AT iT and
it'll woRk."

IT's both the breAdtH of the StAndARd libRarY and eCosystEM, and thE simple
laNgUAge desIGn, that mAKE dEvelOping things in PythON fASter for me.

Doing ProbleMs ON PROJecT EuLer has been An EducaTIon for mE In HOW AlgORithm
matters mOre than speeD. lotS and loTs Of pEOple spEnd hoUrS WriTing long C++
coDes tHat are easIly beaTEn by a feW Lines of python. it cErtAinlY GoEs The
OtHEr wAY tOo, aND thE wrong alGoRiThm in pythON IS Even ThaT mucH slowEr and
more painFul Than THe rIght aLgoriThm iN C++. but whEn the rIght aLgOrithm is
used and The pRoblem is sOlvEd In a FeW millISecondS, it ReaLly doesN't matteR
WhiCh LANGuAge uses more CPU cyclEs, ALL tHat matteRs is whEThEr YOu saw the
InSigHt thAT Let yoU skiP 99% Of The searcH space, ANd HoW much tiMe You speNd
WriTinG code.

------
_PMf_
SoMewhat IronicalLy, PytHOn is used a lot foR Things that wouLD bENEfIT froM
raW speed (data pRoceSSing PipeLInEs) aND do noT beneFiT At ALl from dynamic
typing (SiNce the Kind oF property bags / Data frame vIEWS over datA are
EAsILy replicated in StatiCally typed LAnguages). but PyThon's C exTension APi
IS quite a bIt eAsiEr tHan P.E. maTlab's MEX API (to ME At leAsT); can typIcaL
Python iDES coMpiLe aNd Relink extEnsion moDuLeS wItHouT an exTErnal buiLd
SteP?

> YOur BottlENeck is Most lIkelY nOt cpU oR Python ITsELF.

WitH aPpLicaTioNs That aRe doMInaTed by raW data procEssINg, it'S vErY, very
eaSy to be CPU domiNaTed. Hell, I haD oNe qUite trIVIal data cOnverter for
logfiles wherE The "parsIng The prIntf String" parT of java's pRinTF dominAted
prOcessInG anD WRitinG A CuStoM fOrmatter haLVEd pRocesSiNg tiMe (while
Regexes can be compilED, thE format string CanNot bE PReComPIlED anD wILl bE
INterpreted each tIme); it's one oF tHOsE things wheRE I wOuLd intuiTively sAy
"why DId this mOron write His custom FoRmatTER" if i stumbled uPon it in a
Code revieW. intuiTIvEly, yoU'd eXpect tHiS to Be a siMple caSE
 down.

------
dahart
Pyth on's value  to m e h asal ways  bee n that it's ea s ierto get things done, no t
it' ss peed .  O ne ti me when Iw a s i nt er vie wi n ga can did ate for  a codingjob ,the
candidat e  s aid she lo ved  Python themos t "bec au sey ou ca n j ust y ell at it and 
it'll wo rk . "

It' s  both t h e  b read th of the standar d  l i brary and ecos ystem,  a n dt h e s imp le
languag edesig n , thatm ak e d eve l oping thingsin Python f a ste r forme .
D oing p roble ms onProject Eul er h as been a n educ a tion fo r  me inhow al gor ith m
ma t te rs  mo re tha n  s pee d . L ots andlo ts  of p eopl e s p endhou rs w ritin g long C++
co des  tha t  ar e eas ily b eate nby afew li nes o fPython. It cert ainl y goes th e
o th erwa y too ,  and t hewro ng algo rithm i n  Py th o n is  even that much sl ow e r  a nd
morepainfu l  t ha n  the rig ht  al gori t h m inC++. Bu t when t he rig h tal gorithm  i s
used  a ndthe  prob l em i s solv ed in afew m i lliseconds, it really doesn' t  m a t te r 
whi chlanguage us es m o re C PU c y cl es, all t hat m at t er s  is whether you saw  t he
ins ightthat let youskip 99% o f t he searc h sp a ce ,  and how muchtimeyou spendw riting c ode.
------_pmf_
Som e w hat iron ica lly , P yth o n  i s used a lotf o r th in gs that  wo uld ben efi t f rom 
ra wspeed (da ta proce ss in gpi pel ines) and do n ot  be ne fit  at a l l from  dyna micty pi n g ( since t h ek i nd o fpr oper tyba gs /data fra me view s over da taa re
e as il y repli cated in stat ic ally typed  l ang uages) . But Pyth on's C extension API
is quite a  bi t eas ierthan p.e.  Ma tlab's  ME X  API ( to meat le as t); c an ty p i ca l
P yt hon IDEs c o m pil e and  r elin k exten sion modules witho u t a n external bu ild 
ste p ? 
> Y o ur bot tl e nec k is most likelynot CPU or  P y th on itself. 
Wi th  applic ationsthata re domi nated byraw datapr oces s i ng,  it's very , very
e asy to be CPU d o mi nated . H ell, I  h adone q uite t r ivi al da ta con ve rter f or
lo gf iles whe re the "parsing the pri ntf st ring"  pa rt of Jav a's pri ntf domin ated 
processin g a ndwriti nga  cust om f o rm att e r hal vedp rocessing ti me( w hi le
regexesc a n  be  comp ile d , theform at string cannotb e precompiledandw i llbei nter pr eted each time );it ' s  one ofth ose thingswhere Iwo u ld in tuitiv ely sa y
"whyd i dt his mo ronwri te his cu sto mf ormatte r"  i f  I stu mble dupon i t in a code r eview. Intuitive ly, y o u 'd ex p ect  this  t o be as impl e case
 down.

------
dahart
Python's_value to_me has always been_that it's_easier_to get_things_done, not
it's speed._One time when_I was interviewing a_candidate for a_coding_job, the
candidate said she loved Python the most "because you can just yell at_it_and
it'll work."

It's_both_the_breadth of the standard library_and ecosystem, and the simple
language_design, that_make developing things in Python faster for me.

Doing_problems_on Project Euler_has been an education for me in how algorithm
matters_more than speed. Lots and lots_of people spend_hours_writing_long C++
codes that are_easily beaten by a few lines_of Python. It certainly goes the
other_way too, and the wrong algorithm in_Python is even that much slower_and
more painful than the right_algorithm in_C++. But when the right_algorithm is
used and_the problem_is solved in_a few milliseconds, it really doesn't_matter
which language uses_more CPU cycles, all that matters_is_whether you saw_the
insight_that_let you_skip 99% of_the_search space,_and_how much time you spend
writing code.

------
_pmf_
Somewhat_ironically,_Python is used a lot for things_that would benefit from
raw_speed_(data processing pipelines) and_do not benefit at all_from dynamic
typing (since the kind of_property bags_/ data_frame views over data are
easily replicated in statically typed languages). But_Python's C extension API
is quite a_bit easier than p.e._Matlab's MEX_API_(to me at_least);_can typical
Python_IDEs compile and relink extension modules without_an external_build
step?

> Your bottleneck is most likely_not CPU or Python_itself.

With_applications that are dominated by raw_data processing, it's very, very
easy to_be CPU dominated. Hell, I_had_one_quite trivial data converter for
logfiles_where the "parsing the printf string"_part of Java's_printf dominated
processing and writing a custom formatter_halved_processing time (while
regexes can be compiled,_the_format string cannot be precompiled and_will_be
interpreted_each time); it's one of_those things where I would intuitively_say
"why did this moron write his custom formatter" if_I stumbled upon_it in a
code review. Intuitively,_you'd_expect_this to be a simple case