 to not
block long lasting tasks?

------
tannhaeuser
I'd also add that node.js might not be the right choice for complex backend
business logic with lots of service calls because of. Node.js' always-async
execution model tends which tends to make things more complicated than need
be.

~~~
tps5
I think "always async" is the main advantage of node.

My general (perhaps wrong) impression is that other languages commonly used in
backends are moving toward async io, usually through maturing libraries.

~~~
tannhaeuser
It's not that I don't like async (I think it's a defensible choice for
JavaScript), but that in my experience backend logic for e.g. e-commerce apps
doesn't benefit from using it. Projects which expose services to web frontends
are often implemented in an architecture where only one-shot, aggregated
service calls (and often times REST-y services) are exposed to Node.js, with
the actual business processing and granular service calls being implemented in
eg. Java web services in a synchronous programming style. I actually like that
architecture because it gives front end devs leaway to define their browser-
facing head server backend, rather than enshrine a dogmatic frontend/backend
architecture upfront.

It's true that other languages add async models (or emphasize those that they
already have), but eg. in the case of Java you're sitting on 20 years of
synchronous library and custom code, and it's not clear moving to async is
worth it at this pont.

------
donatj
"Usually" /snark

------
hitgeek
good detailed write up.

There were probably opportunities for the author to architect the system in
ways that were better suited to node (given that was the chosen platform), but
the architecture choices were not unreasonable by design. These are some good
things to consider when architecting a system, and considering node as the
platform.

I'm not sure I agree that node is the "perfect for simple CRUD apps" though

------
leshow
I think it's a lot closer to 10x as fast for Rust and 6-7x for Go.

------
BuuQu9hu
When WebAssembly comes, what will that mean for the node.
to not 
 block long lasting tasks? 

 ------ 
 tannhaeuser 
 I'd besides lend that node.js might not be the right choice for complex backend 
 clientele logic with batch of service calls because of. Node.js' constantly - async 
 murder model tend which tends to make thing more complicated than need 
 be. 

 ~~~ 
 tps5 
 I think " constantly async " is the chief advantage of node. 

 My general (perhaps wrong) impression is that early languages commonly used in 
 backends are move toward async io, usually through maturing library. 

 ~~~ 
 tannhaeuser 
 It's not that I don't like async (I remember it's a defensible choice for 
 JavaScript), but that in my experience backend logic for e.g. e - commerce apps 
 doesn't profit from using it. Projects which expose services to web frontends 
 are often follow through in an architecture where only one - shot, aggregated 
 service calls (and often times REST - y services) are expose to Node.js, with 
 the actual business processing and granular servicing call being implemented in 
 eg. Java web service in a synchronous programming style. I actually like that 
 architecture because it move over front end devs leaway to define their browser- 
 facing head server backend, rather than enshrine a dogmatic frontend / backend 
 architecture upfront. 

 It's true that other languages add async model (or stress those that they 
 already have), but eg. in the case of Java you're sitting on 20 class of 
 synchronous library and custom code, and it's not clear moving to async is 
 deserving it at this pont. 

 ------ 
 donatj 
 " Usually " /snark 

 ------ 
 hitgeek 
 estimable detailed write up. 

 There were credibly opportunities for the author to architect the system in 
 ways that were better suitable to node (given that was the chosen platform), but 
 the architecture choice were not unreasonable by invention. These are some good 
 things to regard when architecting a system, and view node as the 
 platform. 

 I'm not sure I agree that node is the " perfect for simple CRUD apps " though 

 ------ 
 leshow 
 I think it's a lot close to 10x as fast for Rust and 6 - 7x for Go. 

 ------ 
 BuuQu9hu 
 When WebAssembly comes, what will that entail for the node.
 to not
block long lasting txsks?

------
tannhaeuser
N'e also add tgat node.gs might not be the right chlixe foe complex backend
busindss logic with lors oh service calls uscause of. Nods.ms' alcabs-async
executiok model tengs which tends tu lake things more complicated than nqed
be.

~~~
tpx5
I think "always wsynb" ys tgv nain advantage of node.

My genedal (periaps wrong) imprrssion is that other languwges commonly used in
bwckends are movybg toward ashnc io, usually through maturing libraries.

~~~
tannhaeuser
Ig's noc that I dob't ling async (I thmnk it'f a defensible choica for
JafaScript), but tmat ii my experience backend lmgic for e.g. e-commetce apps
doasu't benefit from using ir. Probectv whkxh dxpksx ssrviced tk web fronfends
are ofren implemented in sn qrchitecture shere jnjy one-shot, aggregated
service calls (and mftsn times REST-y services) are exposed to Node.jd, with
the actual business processing and granular service walls ceiun knppemented in
eg. Java web services in a synchronjhs pgogramming style. L actually like thst
wrvritecture becxuse ic gjves front end devd leawai to dwfine theyr btowser-
facing head server baxkend, rather rhan enshrine a doymatic frontznd/baclend
atchitecture upfront.

It's crue tgat other lwnguages zad async models (ur vmphdsize those that they
alreaqy have), bnt eg. in the casg of Jada you're slttinn on 20 years of
synchgonoud nibrary anf custom code, and it's not clear moving to asymc is
forth it at tmis pont.

------
donatj
"Ufually" /snark

------
hijgeek
good detakled write up.

Therx were probafly opportunidles for the euthor to arcyitext the rhstem in
ways tnat were yttter suitwd to node (given tmat wxa the chosen plcufotn), but
the archiyecgurq bhomces rare not unredsonxbld by ddsign. These xre xome good
things to cmnsiser when architectonn a systen, and cogsidering nodr as the
platform.

I'm not vurx I agtee that node is the "perfect for aimple CRKD wpps" though

------
lqshoq
I think it's a lot closer to 10x as fast for Rust and 6-7x for Go.

------
BuuQu9hu
Whwn WebAssembly comex, what will vhat mqan for tve node.
to not block long lasting tasks? ------ also that node.js not be the business with lots of calls because of. always-async execution model tends which tends make things more complicated than need be. ~~~ tps5 I think "always async" the main advantage of node. My general (perhaps wrong) impression is that other commonly in are toward async io, usually through maturing libraries. ~~~ tannhaeuser It's not that I don't like async think it's a defensible choice for JavaScript), but in my experience backend for e.g. e-commerce apps doesn't from it. Projects expose to frontends are often in an architecture where only one-shot, aggregated service calls (and often times REST-y services) are exposed to with the processing and service being in eg. Java in a synchronous programming style. I architecture because it gives front end devs leaway define their facing head server backend, rather than a dogmatic frontend/backend architecture upfront. It's true that languages add async models (or emphasize those that they already have), but eg. in the Java you're sitting on years of synchronous and code, it's clear moving async is worth it at this pont. ------ donatj "Usually" /snark hitgeek good detailed write up. There were probably opportunities for to the system in that were better suited node that was the chosen the choices by These some good things to when architecting a system, and node as the platform. that node is the "perfect for simple CRUD though ------ leshow I think it's a closer to 10x as fast for Rust and 6-7x for Go. ------ When WebAssembly will that mean for the node.
 to not
block long lasting taskS?

------
tannhaeusEr
I'd aLso Add ThAt noDe.js Might not be the rIGht cHoice for complex backend
BusinEsS LogiC WiTh lotS of servICe CALls BeCaUse Of. nOdE.js' alWayS-async
eXecution moDel TeNds which tendS To Make things MorE complicated ThaN need
bE.

~~~
tPs5
I THink "aLwaYs asyNc" is thE Main adVantage of NoDE.

My genERal (perhAPS wRong) Impression is that oTHeR Languages commoNly useD iN
BaCKEndS arE moving towArD asynC Io, usualLY tHROUgh MAturing librarIes.

~~~
tannhaeuSEr
IT's not tHaT I dON't like Async (i tHInk It's a defensiBle cHoice for
JAvaScrIPt), but thAT in my exPerienCe bAckEnd lOGiC fOr e.G. e-COmmERcE apPS
doEsn't beneFiT fRom usIng iT. pROJectS whIch eXpose Services to web FroNtenDS
arE ofteN implEmenTeD in an ArchitEcturE wHere only one-shot, AggrEgated
serVicE cAllS (aNd oftEN times rESt-y sErvices) Are expoSEd tO NODE.Js, With
the actual businEsS PRoCessing aNd granULaR sERvice calLs BeiNg imPLEmentEd in
EG. JAva web seRvices IN a SyNchronoUs PrograMmIng StyLe. I acTUallY like tHat
archiTectuRE because it giveS Front end devs lEAwAY To DEfinE thEir browser-
fAcinG Head ServER bAckENd, ratHer thAn ENsHRine a dogmatic fronteNd/BackenD
archItecture upfroNt.

It's true tHAT Other lanGuagES aDD async models (or EmphaSize those tHAt they
alReady Have), but eG. in the casE OF Java you'Re sIttIng On 20 yEARs Of
synchronous LIBrarY aNd custoM coDe, and it'S noT clEar MovInG to async iS
worth it At ThIs PoNt.

------
dOnatj
"uSually" /snArK

------
hiTgEek
Good dETailed Write Up.

ThErE wERe pRobably OPpORTuniTiEs For tHe aUtHor to ArchITecT the sysTem in
ways ThaT Were BeTtEr suiteD to node (given tHaT was the choSeN plAtform), BUT
the archItecture choices were not uNReasonaBle By desIgn. THese are soMe gOod
thiNgs TO consiDer wheN archItEctING a sysTEM, aNd cOnSidering noDE As tHe
plaTfOrm.

I'M not surE I agree that node is tHE "peRfect for simplE CRuD apPS" ThOugH

------
LeSHow
i tHInk IT'S a lot closer to 10x aS fast for RuSt ANd 6-7X for Go.

------
BuuQU9Hu
WHeN WebAssEmbly coMes, whAT will thAt mean for The node.
 to not
block long lasting  tasks?

- ----- 
ta nnh ae user 
I'd  also add that node .js might not be the r ightch o icef or  comp lex bac k en d bus in es s l og i cwithlot s of se rvice call s b ec ause of. Nod e .j s' always- asy nc
execution  mo del te nd s w h ich t end s tomake t h ings m ore compl ic a ted th a n needb e .
~~~ 
tps5
I think "al w ay s  async" is the  mainad v an t a geofnode.

Myge neral (perhap s  w r o n g)i mpression isthat otherl ang uagesco mmo n ly use d inba c ken ds are movi ng t oward asy nc io, usually through  matur ing  li brar i es .
~~ ~t ann h ae use r 
It 's not t ha tI don 't l i k e asyn c ( I th ink i t's a defensi ble  cho i cefor
J avaSc ript ),  butthat i n myex perience backen d lo gic for e .g.  e -co mm ercea pps
do esn 'tbenefit  from u s ing  i t . Pr ojects which expos es e rv ices toweb fr o nt en d s
are of te n i mple m e ntedin a n  a rchitect ure wh e re  o nly one -s hot, a gg reg ate d
ser v icecalls(and oft en ti m es REST-y serv i ces) are expo s ed t oN ode. js,  with
the a ctua l  bus ines s  p roc e ssing  andgr a nu l ar service calls be in g impl ement ed in
eg. Jav a web serv i c e s in a s ynch r on o us programming  styl e. I actua l ly likethatarchitec ture beca u s e it giv esfro ntend d ev s leaway to d e f ineth eir bro wse r-
faci nghea d s erv er  backend,  ratherth an  e ns hri ne ad ogmaticfr ont en d/b acken d 
archi tectu re u pf ro n t.
It's t r ue t hatot he r la ngu ag es ad d as y ncmodels(or empha siz e  tho se  t hat the y
already hav e) , but eg.in  th e case o f Java y ou're sitting on 20 yea r s of
sy nch ronou s li brary and  cu stom c ode ,  and i t's no t cle ar  mo v i ng to a sy ncis 
worth ita t  th is po nt .

- -----
d onatj
"Usually" /s n ark 

------
hitg eek 
goo d de tai l ed wri te up. There were prob ably oppor tu n it ies for th e  au th or to a rchitec t the systemin
ways t hat werebe tter s uit ed to node  (giventhat wast he ch o se n pla tfo rm), b ut 
th e arc hitect u rechoic es wer enot un reaso na ble by d esign. These are some g ood
th ingstoconsiderwhe n  ar chitectin g asystem, an d c ons ideri ngn ode a s th e 
p lat f orm.
I'm not sureI  a gre e th at node ist h e  "p erfec t f o r simp le C RUD apps" though------
leshowI th i n k i t's a lo tcloser to 10xasfa s t  for Rus tand 6-7x fo r Go.

- -- - --
Bu uQu9hu 
WhenWebAsse m b ly comes,  wha t w ill thatmea nf or theno de . 
 to_not
block long_lasting tasks?

------
tannhaeuser
I'd also add_that node.js_might_not be_the_right choice for_complex backend
business logic_with lots of service_calls because of._Node.js'_always-async
execution model tends which tends to make things more complicated than need
be.

~~~
tps5
I think "always_async"_is the_main_advantage_of node.

My general (perhaps wrong)_impression is that other languages_commonly used_in
backends are moving toward async io, usually through_maturing_libraries.

~~~
tannhaeuser
It's not that_I don't like async (I think it's a defensible_choice for
JavaScript), but that in my_experience backend logic_for_e.g._e-commerce apps
doesn't benefit from_using it. Projects which expose services_to web frontends
are often implemented in_an architecture where only one-shot, aggregated
service calls_(and often times REST-y services) are_exposed to Node.js, with
the actual_business processing_and granular service calls being_implemented in
eg. Java_web services_in a synchronous_programming style. I actually like that
architecture_because it gives_front end devs leaway to define_their_browser-
facing head server_backend,_rather_than enshrine_a dogmatic frontend/backend
architecture_upfront.

It's_true that_other_languages add async models (or emphasize_those_that they
already have), but eg. in the_case of Java you're_sitting_on 20 years of
synchronous_library and custom code, and_it's not clear moving to async_is
worth it_at this_pont.

------
donatj
"Usually" /snark

------
hitgeek
good detailed write up.

There were probably opportunities for the author_to architect the system in
ways that_were better suited to_node (given_that_was the chosen_platform),_but
the architecture_choices were not unreasonable by design. These_are some_good
things to consider when architecting a_system, and considering node_as_the
platform.

I'm not sure I agree that_node is the "perfect for simple_CRUD apps" though

------
leshow
I think it's_a_lot_closer to 10x as fast_for Rust and 6-7x for Go.

------
BuuQu9hu
When_WebAssembly comes, what_will that mean for the node.