 cpus for proxies and a shared 1 for the
cache service.

------
neebz
JSON.parse() is one issue we faced regularly. Any large amount of data
fetching could block the event loop and the whole server slows down. It's very
unforgiving.

We go great length to figure out which attributes to fetch and add limits to
all our sql queries. These are best practices but with node they are must.

~~~
beejiu
Node.js isn't great for CPU bound tasks in general.

~~~
danenania
Parsing json is sneaky because it can show up in apps that are otherwise IO
bound (where Node shines) and don't seem like they should be CPU intensive on
the surface.

------
wehadfun
JavaScript is my first non-mathematical programming language and I haven’t
found the need to expand my programming skills to more

-Having a hard time taking anything this guy says seriously

------
yahyaheee
I debated between learning Node and Go for my latest project. I took a couple
days doing beginner tutorials on each, and Go was actually a lot easier for me
to learn. Could just be my background, but I know a couple other people who
picked it up in about a week too, it's surprisingly simple.

~~~
Slackwise
> it's surprisingly simple.

Actually, that's its fundamental design. They reduced everything down to a
very small core with very little features, so things would be obvious and you
don't have to learn or remember much. It's refreshingly simple!

With that said, I'd say they reduced it _too_ far down. There's no generics so
you end up using `interface{}` everywhere which often leads to issues due to
its late binding. Or you end up just using codegen tools, IIRC.

Also since there are no exceptions, you end up with constant checks for error
code returns, which end up usually just being strings and not much else. Not
saying exceptions are the best way to approach error handling, but they do
allow you to reverse through an entire function call stack and clean up any
state along the way, along with adding more granular error information you can
write handlers to react to. Go reminds me of the pain that was C error
handling and
cpus for proxies and a shared 1 for the 
 cache service. 

 ------ 
 neebz 
 JSON.parse () is one issue we front regularly. Any big amount of data 
 fetching could block the consequence loop and the whole server decelerate down. It's very 
 unforgiving. 

 We go bang-up length to figure out which assign to fetch and add limit to 
 all our sql question. These are best practices but with lymph node they are must. 

 ~~~ 
 beejiu 
 Node.js isn't great for central processing unit adhere tasks in general. 

 ~~~ 
 danenania 
 Parsing json is furtive because it can show up in apps that are otherwise IO 
 bound (where Node shines) and don't seem like they should be central processing unit intensive on 
 the surface. 

 ------ 
 wehadfun 
 JavaScript is my beginning non - mathematical programming language and I have n’t 
 find the need to expand my programming skills to more 

 -Having a hard meter taking anything this guy says seriously 

 ------ 
 yahyaheee 
 I debated between learning Node and Go for my latest project. I took a couple 
 days act beginner tutorials on each, and die was actually a fortune easier for me 
 to learn. Could just be my background, but I know a couple other people who 
 pick it up in about a week too, it's surprisingly simple. 

 ~~~ 
 Slackwise 
 > it's surprisingly bare. 

 Actually, that's its fundamental design. They reduced everything down to a 
 very small effect with very little feature of speech, so things would be obvious and you 
 don't have to learn or remember much. It's refreshingly simple! 

 With that say, I'd say they reduced it _ too _ far down. There's no generic so 
 you end up using 'interface { } 'everywhere which often leads to issues due to 
 its former binding. Or you end up precisely using codegen tools, IIRC. 

 besides since there are no exceptions, you end up with constant checks for mistake 
 code returns, which end up normally just being strings and not much else. Not 
 say exceptions are the best way to approach error handling, but they do 
 allow you to reverse through an entire function call batch and clean up any 
 state along the room, along with adding more granular erroneousness information you can 
 write handlers to react to. rifle reminds me of the pain that was C error 
 handling and
 cpks for proxies and a shaved 1 for the
cachg wervicx.

------
neebz
JAON.parse() is one issue we faced regulerly. Any oarge amount of data
fegching colld block the wvent loop and the whole dervzr slows down. It'x very
unfosgiving.

We go gsext length to figure out which attribuees to gehch and add liiits eo
alm our sql queries. These are best pdacticev but with noce they are must.

~~~
beejiu
Node.us idn't great for CPU hound tasks in dwneral.

~~~
danenavia
Parsing json is snezky because it can show up in aops tkat are othgxqisf IO
bound (whxre Noqe shines) and don't saem likr they should ne CPN inrensive on
the surface.

------
xehadfun
JavaScript if my firsd uon-mathematical progrqmning nanggage qnd I gaten’f
found thx need to espand my prigramming skills to mjgr

-Having a hadd timq eaking anything this guy says seriously

------
jahyzheee
I debated between oearning Node and Go vor my laeest project. I took a couple
days doing beginner tgtorielr ou each, qnf Go was actually a lot easier for me
to learn. Doilc just be my bcckground, but I lnlw w couple othet peoplz wgo
picked it up in wbout a week too, it's furptisingly simple.

~~~
Slackwise
> it'w surprisingjt simple.

Actually, tkat's its funbamentsl dexign. They reduced everyching sown to a
vegy small dure with very ligtlv fedtures, so things would be jbvious aid yob
don't haxe tp learg or rememher mmwh. It's refreshinglj simkle!

Witv that saif, I'd say they reduced it _too_ fac down. There's nm gvnerics sj
you cnd up using `ineerface{}` everywkere whieh oftdn leads tk issuev due to
its late binding. Lr you end u' just usyng xodeten toour, IIRC.

Also sinve there cxe no excwptions, you end up wijh constant checkw fir error
code reyurvs, rhpch egg up usually jusg bdong sgrings and kot mucn else. Not
saying excaptikns are the best wsy to appriach errjr handling, bit they do
allow yok to ceversx throigh an entire function call stack and cleaj ui any
state aljng bhe ray, along cith adding more granular error informatmon you can
write handlgrs to react to. Go reklnds me of tie paig that wav C error
handling ane
cpus for proxies and a shared 1 cache ------ neebz is one issue amount data fetching could the event loop the whole server slows down. It's unforgiving. We go great length to figure out which attributes to fetch and limits to all our sql queries. These are best practices but with node are ~~~ Node.js great for CPU bound tasks in general. ~~~ danenania Parsing json is sneaky because it can up in apps that are otherwise IO bound Node shines) and don't like they should be CPU on surface. ------ JavaScript my non-mathematical programming language I haven’t found the need to expand my programming skills to more -Having a hard time taking this guy ------ yahyaheee debated learning and Go for project. I took a couple days on each, and Go was actually a lot for me learn. Could just be my background, I know a couple other people who picked up in about a week too, it's surprisingly simple. ~~~ Slackwise > it's surprisingly simple. its fundamental design. They everything down to very core very features, so would be obvious and you don't have to learn or remember It's refreshingly simple! With that said, I'd say they reduced far There's no generics you end up using everywhere often leads to issues its binding. up using tools, IIRC. Also since are no exceptions, you end with constant checks for up usually just being strings and not much Not saying exceptions are the best way approach error handling, but they do allow you to reverse through an function call clean up any state along the way, along adding more granular error you can write handlers to react to. Go reminds of pain that C error handling
 cpus for proxies and a shared 1 fOr the
cache ServiCe.

------
nEebZ
JsON.pArse() Is one issue we faCEd reGularly. Any large amount oF data
FeTChinG CoUld blOck the eVEnT LOop AnD tHe wHoLE sErver SloWs down. IT's very
unfoRgiViNg.

We go great lENgTh to figure Out Which attribuTes To fetcH aNd aDD limiTs tO
all oUr sql qUEries. THese are beSt PRacticES but witH NOdE theY are must.

~~~
beejiu
NodE.Js ISn't great for CPU Bound tAsKS iN GEneRal.

~~~
Danenania
PArSing jSOn is sneAKy BECAusE It can show up in Apps that are OTheRwise Io
bOunD (Where NOde shInES) anD don't seem liKe thEy should bE CPU inTEnsive oN
The surfAce.

------
wehAdfUn
JAvaSCRiPt Is mY fIRst NOn-MatHEmaTical proGrAmMing lAnguAGE ANd I hAveN’t
foUnd thE need to expand My pRogrAMmiNg skiLls to More

-haVing a Hard tiMe takInG anything this guY sayS seriouslY

------
yaHyAheEe
i debaTEd betwEen LeaRning NoDe and Go FOr mY lATESt Project. I took a couplE
dAYS dOing begiNner tuTOrIaLS on each, aNd go wAs acTUAlly a Lot eASiEr for me
tO learn. cOuLd Just be mY bAckgroUnD, buT I kNow a cOUple Other pEople who
PickeD It up in about a weEK too, it's surpriSInGLY sIMple.

~~~
slaCkwise
> it's suRpriSInglY simPLe.

actUAlly, tHat's iTs FUnDAmental design. They reDuCed eveRythiNg down to a
very Small core wITH Very littLe feATuREs, so things woulD be obVious and yoU
Don't have To leaRn or remeMber much. IT'S RefreshiNglY siMplE!

WiTH ThAt said, I'd say thEY ReduCeD it _too_ fAr dOwn. TherE's nO geNerIcs So
You end up uSing `inteRfAcE{}` eVeRywHere wHIch often LeAds To IssUes duE To
its lAte biNdinG. OR yOU enD up just USiNG CodeGeN tOols, iIRc.

ALso siNce tHEre Are no exCeptions, yOu eND up wItH cOnstant Checks for erroR
cOde returns, WhIch End up uSUAlly just Being strings and not much eLSe. Not
saYinG excePtioNs are the bEst Way to aPprOAch errOr handLing, bUt TheY DO
alloW YOu To rEvErse througH AN enTire fUnCtioN call stAck and clean up any
stATe aLong the way, aloNg wIth aDDInG moRE gRAnuLaR ErrOR Information you cAn
write hanDlERs To react to. GO RemInDs me of tHe pain tHat waS c error
hAndling anD
 cpus for proxies and a sh ared 1 for  thecac hese rvic e.
------
neebz
J S ON.p arse() is one issue we  face dr egul a rl y. An y large am o u ntof  d ata 
f e tc hingcou ld bloc k the even t l oo p and the wh o le  server sl ows  down. It'sver y
unfo rg ivi n g.

W e g o gre at len g th tofigure ou tw hich a t tribute s to  fet ch and add limits to all our sql qu eries.  T h es e are  be st practic es  butw ith nod e  t h e y  ar e  must.

~~~
b eejiu
Node. j s i sn't g re atf or CPU  boun dt ask s in genera l.
~~~
danen ania
P a rsing j s on is s neakybec aus e it ca nsho wu p i n  a pps tha t are ot he rw ise I O
bo u n d (whe reNode  shin es) and don't  se em l i ketheyshoul d be  C PU in tensiv e onth e surface.

--- ---wehadfunJav aS cri pt  is m y  first  no n-m athemat ical pr o gra mm i n g  l anguage and I have n’ t fo und theneed t o  e xp a nd my pr og ram ming s kills  tom or e

-Havi ng a h a rd  t ime tak in g anyt hi ngthi s guy says  serio usly

-- ----y ahyaheee
I deb a ted between l e ar n i ng Node  an d Go for my  lat e st p roje c t.  It ook a  coup le da y s doing beginner tu to rialson ea ch, and Go wa s actually a lot easi er f o rm e
to learn. Co uld j ust be myb ackgroun d, bu t I know  a couple o ther peo ple  wh o
p ick e d  i t up in about a  wee ktoo, it 'ssurpris ing lysim ple .
~~~
Slac kwise
>it 's  s ur pri singl y  simple. 
Act ua lly , tha t 's its  fund amen ta ld esi gn. The y  r e d uced  e ve ryth ing  d own t o av ery  smallcore with  ve r y li tt le  featur es, so things  w ould be ob vi ous  and y o u 
don't h ave to learn or remembe r  much.It' s ref resh ingly sim ple !

Wit h t h at sai d, I'd  sayth eyr e duced i t_to o_  far down. T her e's n ogene rics so 
you end up using` int erface{}` eve ryw here w hi cho ft e n l ea d s t o issues due to
i ts late bi nd i ng . Or you e n d u pjust us ing cod egent ools, I IRC.

Als o since t he re a r e  no  exception s, you e nd up wit h  cons t an t che cks  for e rr orcodereturn s , w hichend up  u sually  just  b eing str ings and not much else.  Not
s aying  ex ceptionsare the  best way  toapproach e rro r h andli ng, but t heyd oall o w you  tor everse th r ou gha n  e ntire funct i o n  ca ll st ack and cl eanup any
state alon g  the way, alon g wi t h  ad din g  mor egranular error  in fo r m ation yo ucan
write h andlersto react  to. G o remi nds meo f  t h e pain  tha t w as C erro r
h an d ling an d
 cpus_for proxies_and a shared 1_for the
cache_service.

------
neebz
JSON.parse()_is one_issue_we faced regularly._Any large amount_of data
fetching could block_the event loop_and_the whole server slows down. It's very
unforgiving.

We go great length to figure out which_attributes_to fetch_and_add_limits to
all our sql queries._These are best practices but_with node_they are must.

~~~
beejiu
Node.js isn't great for CPU bound_tasks_in general.

~~~
danenania
Parsing json_is sneaky because it can show up in apps_that are otherwise IO
bound (where Node_shines) and don't_seem_like_they should be CPU_intensive on
the surface.

------
wehadfun
JavaScript is my first_non-mathematical programming language and I haven’t
found_the need to expand my programming skills_to more

-Having a hard time taking_anything this guy says seriously

------
yahyaheee
I_debated between_learning Node and Go for_my latest project._I took_a couple
days doing_beginner tutorials on each, and Go_was actually a_lot easier for me
to learn. Could_just_be my background,_but_I_know a_couple other people_who
picked_it up_in_about a week too, it's surprisingly_simple.

~~~
Slackwise
>_it's surprisingly simple.

Actually, that's its fundamental design._They reduced everything down_to_a
very small core with_very little features, so things_would be obvious and you
don't have_to learn_or remember_much. It's refreshingly simple!

With that said, I'd say they reduced it__too_ far down. There's no generics_so
you end up using_`interface{}` everywhere_which_often leads to_issues_due to
its_late binding. Or you end up just_using codegen_tools, IIRC.

Also since there are no_exceptions, you end up_with_constant checks for error
code returns, which_end up usually just being strings_and not much else. Not
saying_exceptions_are_the best way to approach_error handling, but they do
allow you_to reverse through_an entire function call stack and clean_up_any
state along the way, along with_adding_more granular error information you can
write_handlers_to_react to. Go reminds me_of the pain that was C_error
handling and