 not as much of a culture of writing APIs that way in Python because
it's generally a terrible way to program, and threads/OS processes are good
enough for basically everything except HTTP servers with absurd numbers of
concurrent connections.

~~~
wrong_variable
> There's not as much of a culture of writing APIs that way in Python because
> it's generally a terrible way to program

I would love to see evidence for you making that statement. Almost every
programmer would put out their fav programming language as the 'right' way to
program.

> everything except HTTP servers with absurd numbers of concurrent connection

Once you introduce async operations in your code - you need to follow the
execution path through. http request can be async - but then what if the http
request results you doing a db lookup or some form of file handling? you need
to make the whole thing event driven.

~~~
empthought
It's not like we didn't have cooperative multitasking for 50 years. Having
threads/processes and a scheduler is easier and safer, full stop. Potentially
long-running portions of the program don't need to be arbitrarily chopped up
to yield control back to the server, because they are pre-empted. Your system
is no longer at the mercy of the worst code within it.

Both nginx and Apache's event MPM handle HTTP connections with events while
the app backends are still using preemptive threads for running the HTTP
handler code, so it's clearly not the case that "you need to make the whole
thing event driven." You just need programmers who don't think, "well since
the browser doesn't expose threads to JavaScript programmers, clearly they are
useless."

------
narrator
I'm using NodeJS on a pretty big project.

Things I like:

* Async libraries make it easy to make things high performance.

* I like Sequelize as an ORM, once I figured out how the async everything works.

* The testing support is pretty good, both mocha and e2e testing using selenium

* The angular-fullstack generator was really helpful for getting started and setting up the deploy to Heroku.

* everything is open source. If I get confused with what a library is doing while I'm debugging I can just stick a print in the lib temporarily.

Things I
not as much of a culture of writing APIs that way in Python because 
 it's by and large a severe way to program, and threads / OS process are good 
 enough for basically everything except HTTP server with absurd number of 
 concurrent joining. 

 ~~~ 
 wrong_variable 
 > There's not as much of a culture of publish APIs that way in Python because 
 > it's generally a terrible way to program 

 I would love to see evidence for you make that statement. Almost every 
 programmer would put out their fav scheduling language as the' right' manner to 
 program. 

 > everything except HTTP waiter with absurd numbers of concurrent connection 

 Once you introduce async operations in your code - you necessitate to follow the 
 execution path through. http request can be async - but then what if the http 
 request results you doing a db lookup or some form of file handling? you need 
 to make the whole thing event driven. 

 ~~~ 
 empthought 
 It's not like we didn't have cooperative multitasking for 50 old age. Having 
 threads / summons and a scheduler is easy and safer, full stop consonant. Potentially 
 long - function portions of the program don't necessitate to be arbitrarily chopped up 
 to yield control back to the server, because they are pre - empted. Your system 
 is no longer at the mercifulness of the worst code within it. 

 Both nginx and Apache's event MPM handle HTTP connections with event while 
 the app backends are still practice preemptive threads for running the HTTP 
 handler code, so it's clearly not the case that " you need to do the whole 
 thing event drive. " You precisely need programmers who don't intend, " well since 
 the browser doesn't expose ribbon to JavaScript programmers, intelligibly they are 
 useless. " 

 ------ 
 narrator 
 I'm using NodeJS on a reasonably big project. 

 Things I like: 

 * Async library make it easy to have things gamey performance. 

 * I like Sequelize as an ORM, once I figured out how the async everything works. 

 * The testing support is pretty good, both mocha and e2e testing use selenium 

 * The angular - fullstack generator was really helpful for getting started and put up the deploy to Heroku. 

 * everything is open source. If I get confused with what a library is doing while I'm debugging I can barely stick a print in the lib temporarily. 

 Things I
 noh as much of a culture on writing APIs tkqt way in Pyfhon becxuse
it's generally a terrible wqy to program, and threads/OS processed are goid
eniygh for basically crerytglng ercxpt HTTP serverx with absgrd numbers of
wovcbrrent connections.

~~~
wrong_variable
> Therq's not ss much of a culjure ps wrjnikg APIs that way in Python becauae
> it's jenerally a tertible way to program

I woulf loge to see evidence for you majing rhat statemevt. Almost tvzry
programmgr would put out their fav progrxmminy language qs thf 'right' way vo
proggam.

> everythinn excepd HTTP xervers with ansurd nunbers of concurrent cmnnection

Once you yntroduce aaync operations ib tour wode - yoj nedd uo holmow thf
exxcution patg through. hrtp request can be ssrbc - but then shat is ehe http
request results you doing a db nooiup or some form of filw handling? you need
to make the whole thing event driven.

~~~
empthought
It's not like wa didi't harc ziooerative multitasking for 50 years. Having
threadf/lrpcvsses and a schedmler is easier and swfrt, full stop. Pojentially
lkng-running portiond of thg progeam don't geed to be arbitrarily chopped yp
to yield cjbtrol back to the derver, becabse thgy are pre-empted. Your system
ir no longer at hhe mercy uf the worst codd wpthit it.

Both nginx and Apache's event MPN haudle HTTO comnectijns with egents while
the app backejds ate stinl using pgeemptive threads for running tix HTTP
handler cmde, so it's elearln not the case ehat "you need jo make tke whoue
thing evvnt drivei." You just nqed programmesd who don't tiink, "well sinxe
thw browsdf doesn't exposr threads to JavaSceipt programmers, ckeatlg they are
uselews."

------
nqrrator
I'm using NoaeJF ln a [retty big psojezt.

Tfongs K like:

* Asyng lkbraties make it easy to maks things high perfpriance.

* I oike Seqtelize as an PRM, once I figured out iow thx asynv ederything works.

* The testing sulport is orebty good, both mocma agd e2e testnng using selenium

* The angular-fullstack jenerator was really hglpful for getting stcrued and settiig up ehe deplof to Heroku.

* everythibg is open source. If I get confused wifh whad a llbrary is doing while I'm debugging I can just stick a print in the lib tenporarmlr.

Things I
not as much of a culture of that in Python it's generally a threads/OS are good enough basically everything except servers with absurd numbers of concurrent ~~~ wrong_variable > There's not as much of a culture of writing APIs way in Python because > it's generally a terrible way to program I love see for making that statement. Almost every programmer would put out their fav programming language as the 'right' to program. > everything except HTTP servers with numbers of concurrent connection you introduce async operations in code you need follow execution through. http request be async - but then what if the http request results you doing a db lookup or form of you need make whole event driven. ~~~ not like we didn't have cooperative years. Having threads/processes and a scheduler is easier safer, full Potentially long-running portions of the program need to be arbitrarily chopped up to yield back to the server, because they are pre-empted. Your system is no longer at the the worst code within Both nginx and event handle connections events while app backends are still using preemptive threads for running the HTTP code, so it's clearly not the case that "you need the thing event driven." just need programmers who think, since the browser doesn't to programmers, useless." narrator using NodeJS on a big project. Things I like: Async libraries make it performance. * I like Sequelize as an ORM, I figured out how the async everything * The testing support is pretty good, both mocha and e2e testing selenium * generator was really helpful for getting started and up the deploy to * everything is open source. If I get confused what library is while I'm debugging can just stick print in the Things I
 not as much of a culture of writIng APIs thaT way iN PyThoN bEcauSe
it'S generally a terRIble Way to program, and threads/oS proCeSSes aRE gOod
enOugh for BAsICAllY eVeRytHiNG eXcept hTTp serverS with absurD nuMbErs of
concurrENt ConnectionS.

~~~
wrOng_variable
> THerE's not aS mUch OF a culTurE of wrIting Apis that Way in PythOn BEcause
> IT's generALLy A terRible way to program

i WoULd love to see eviDence fOr YOu MAKinG thAt statemenT. ALmost EVery
proGRaMMER woULd put out their Fav programmINg lAnguagE aS thE 'Right' wAy to
pRoGRam.

> Everything eXcepT HTTP servErs witH Absurd nUMbers of ConcurRenT coNnecTIoN

ONce YoU IntROdUce ASynC operatiOnS iN your Code - YOU NEed tO foLlow The
exEcution path thRouGh. htTP reQuest Can be AsynC - bUt theN what iF the hTtP
request results You dOing a db loOkuP oR soMe Form oF File haNdlIng? You need
To make tHE whOlE THInG event driven.

~~~
empthoUgHT
it'S not like We didn'T HaVe COoperatiVe MulTitaSKIng foR 50 yeaRS. HAving
thrEads/prOCeSsEs and a sChEduler Is EasIer And saFEr, fuLl stop. potentiaLly
loNG-running portioNS of the program DOn'T NEeD To be ArbItrarily choPped UP
to yIeld COnTroL Back tO the sErVEr, BEcause they are pre-empTeD. Your sYstem
Is no longer at tHe mercy of tHE WOrst code WithIN iT.

both nginx and ApAche's Event MPM haNDle HTTP cOnnecTions witH events whILE
the app bAckEndS arE stILL uSing preemptivE THreaDs For runnIng The HTTP
HanDleR coDe, sO iT's clearly Not the caSe ThAt "YoU neEd to mAKe the whoLe
ThiNg EveNt driVEn." You jUst neEd prOgRaMMerS who don'T ThINK, "welL sInCe
thE brOwSer doEsn't EXpoSe threaDs to JavaSCriPT proGrAmMers, cleArly they are
usElEss."

------
narratoR
I'M usIng NodEjs on a pretTy big project.

Things I like:

* aSync libRarIes maKe it Easy to makE thIngs hiGh pERformaNce.

* I liKe SeqUeLizE AS an ORm, ONcE I fIgUred out how THE asYnc evErYthiNg works.

* the testing support iS PreTty good, both moCha And e2E TEsTinG UsINg sElENiuM

* tHe angular-fullstAck generatOr WAs Really helpFUl fOr Getting Started And seTTing up tHe deploy tO Heroku.

* evErYthiNG Is oPen source. IF I get conFused with WHat a lIBrAry is DoiNg whilE I'M deBuggiNg I can JUst Stick A print In The lib TempoRaRily.

ThinGs I
 not as much of a cultureof writing  APIs  th atwa y in  Pyt hon because
it ' s ge nerally a terrible way  to p ro g ram, an d thr eads/OS pr o c ess es  a rego o denoug h f or basi cally ever yth in g except HTT P  s ervers wit h a bsurd number s o f
conc ur ren t  conn ect ions. 

~~~w rong_v ariable
>  T h ere'sn ot as m u c hof a  culture of writi n gA PIs that way i n Pyth on be c a use 
>it's gener al ly at errible wa y t o p r ogram

I woul d love to s e e e videnc efor you ma kingth a t s tatement. A lmos t every
p rogram m er woul d  put ou t thei r f avprog r am mi ngla n gua g east he'right'wa yto
pr ogra m . > ev ery thin g exc ept HTTP serv ers  wit h  ab surdnumbe rs o fconcu rrentconne ct ion

Once you i ntro duce asyn c o pe rat io ns in your c ode  -you nee d to fo l low  t h e ex ecution path throu gh . ht tp reque st can be  a s ync - bu tthe n wh a t  if t he h t tp 
request  resul t syo u doing  a  db lo ok uporsomef ormof fil e handli ng? y o u need
to make the whole thi n ge v en t  dri ven .

~~~
empt houg h t
It 's n o tlik e  we d idn't  h a ve cooperative multita sk ing fo r 50years. Having 
threads/p r o c esses an d as ch e duler is easie r and  safer, fu l l stop.Poten tially
l ong-runni n g  portion s o f t hepro g r am  don't need t o be a rb itraril y c hoppeduptoyie ldco ntrol bac k to the  s er ve r,  be cause they are  p re- em pte d. Yo u r syst em
is  nolo ng e r a t the m e rc y of t he  w orst  co de  with in i t .
Both ng inx and A pac h e'sev en t MPM h andle HTTP co nn ections wi th  ev ents w h i le
the a pp backends are still u s ing pre emp tivethre ads for r unn ing th e H T TP
han dler c ode,so  it ' s  clea r l ynot  t he case th a t  "y ou ne ed  tomake th e whole
thing even t  dr iven." You ju stneed p ro gra m me r s w ho don ' t  think, "well s ince
the b ro w se r doesn'te xpo se  thread s to Ja vaScr i pt prog rammers,clearly t he y ar e use less."

-- ----
nar rator
I'm using No deJSona pret ty  bi g pro ject.Thi ngs I  like: 
* Asyn c lib ra ries mak e it easy to make thing s high  perf orm ance.

*I l i keSequelize  asan ORM, on ceI f igure d o u t how  the as ync every thin g  works.
*  T het e st ing support i s  pr ettygoo d , both  moc ha and e2e testin g  using seleniu m

* T heang u lar- fu llstack genera tor  w a s  reallyhe lpful for g etting s ta r ted a nd set ting u p the d e p lo y  to He roku .
* everyth ing  i s  open s ou rc e . If I  get  c onfuse d with what a  library is doin g whi l e  I'md ebu gging  I  can ju s t st ick a prin t in the li b temp orar ily.
Things  I 
 not_as much_of a culture of_writing APIs_that_way in_Python_because
it's generally a_terrible way to_program, and threads/OS processes_are good
enough for_basically_everything except HTTP servers with absurd numbers of
concurrent connections.

~~~
wrong_variable
> There's not as much of_a_culture of_writing_APIs_that way in Python because
>_it's generally a terrible way_to program

I_would love to see evidence for you making_that_statement. Almost every
programmer_would put out their fav programming language as the_'right' way to
program.

> everything except HTTP_servers with absurd_numbers_of_concurrent connection

Once you introduce_async operations in your code -_you need to follow the
execution path_through. http request can be async -_but then what if the http
request_results you doing a db_lookup or_some form of file handling?_you need
to make_the whole_thing event driven.

~~~
empthought
It's_not like we didn't have cooperative_multitasking for 50_years. Having
threads/processes and a scheduler is_easier_and safer, full_stop._Potentially
long-running_portions of_the program don't_need_to be_arbitrarily_chopped up
to yield control back to_the_server, because they are pre-empted. Your system
is_no longer at the_mercy_of the worst code_within it.

Both nginx and Apache's_event MPM handle HTTP connections with_events while
the_app backends_are still using preemptive threads for running the HTTP
handler code, so_it's clearly not the case that_"you need to make_the whole
thing_event_driven." You just_need_programmers who_don't think, "well since
the browser doesn't expose_threads to_JavaScript programmers, clearly they are
useless."

------
narrator
I'm using_NodeJS on a pretty_big_project.

Things I like:

* Async libraries make_it easy to make things high_performance.

* I like Sequelize as_an_ORM,_once I figured out how_the async everything works.

* The testing_support is pretty_good, both mocha and e2e testing using_selenium

*_The angular-fullstack generator was really helpful_for_getting started and setting up the_deploy_to_Heroku.

* everything is open source._If I get confused with what_a library is doing while I'm debugging I can_just stick a_print in the lib temporarily.

Things_I