 don't like:

* "undefined is not a function". When something goes wrong. This is the error I get 80% of the time.

* async stuff silently swallows exceptions unless I put try{} catch(err) { console.trace(err) } everywhere

* There's a bit of a learning curve with promises.

* Needs a lot more automated testing than a really strongly typed language like Scala.

* Single Threaded. I know how to program using threads, so I view this as a disadvantage.

* No types. I have a lot of type checking asserts at the beginning of dao functions.

If I did it all again and my teammates would oblige, I would have probably
chosen Play/Scala. I actually reimplemnted things from a Play/Scala project I
did a while back (login/signup/forgot password/confirm account) and it took
less time in Play/Scala, even without passportJS and friends. I have about a
years worth of experience learning Scala before I started that project, so it
would probably take longer for a new Scala developer.

~~~
rhinoceraptor
> async stuff silently swallows exceptions unless I put try{} catch(err) {
> console.trace(err) } everywhere

Huh? That's not how async errors work in Node. Try/Catch is not async, the
catch block will not magically transfer to your callback function.

You check for the error as the first parameter in your callback, that's the
standard way of error handling. Throwing errors in Node is considered by most
to be an anti-pattern.

~~~
narrator
That's nice in theory, but third party libraries may throw exceptions if
unexpected things happen at runtime. You'd still have to put the try catch
block there and call the callback in the catch block everywhere.

~~~
rhinoceraptor
That's only for non-async stuff, which is very rare. If you're using some
wacky 3rd party code which throws an Error instead of the accepted convention
of (err, response) callback arguments (or returning a promise), I suggest not
using it.

------
mrmondo
We couldn't even stand 6 months let alone a year. Broken pack depts make it

don't like: 

 * " undefined is not a function ". When something goes wrong. This is the mistake I make 80% of the time. 

 * async stuff silently swallow exceptions unless I put attempt { } catch(err) { console.trace(err) } everywhere 

 * There's a bit of a learning curve with promise. 

 * Needs a lot more automatize testing than a really strongly typed linguistic process like Scala. 

 * Single Threaded. I know how to program using threads, so I see this as a disadvantage. 

 * No types. I have a lot of character checking asserts at the beginning of dao functions. 

 If I do it all again and my teammates would compel, I would have probably 
 choose Play / Scala. I actually reimplemnted things from a Play / Scala project I 
 did a while back (login / signup / forgot password / confirm report) and it took 
 less time in Play / Scala, even without passportJS and friends. I have about a 
 class worth of experience learning Scala before I started that project, so it 
 would probably take longer for a new Scala developer. 

 ~~~ 
 rhinoceraptor 
 > async stuff silently swallows exception unless I put try { } catch(err) { 
 > console.trace(err) } everywhere 

 Huh? That's not how async error work in Node. Try / Catch is not async, the 
 catch block will not magically transfer to your recall function. 

 You see for the error as the first argument in your callback, that's the 
 standard way of error handling. Throwing errors in Node is consider by most 
 to be an anti - pattern. 

 ~~~ 
 narrator 
 That's nice in theory, but third party libraries may throw exceptions if 
 unexpected thing find at runtime. You'd still have to put the try catch 
 block there and call the callback in the apprehension block everywhere. 

 ~~~ 
 rhinoceraptor 
 That's entirely for non - async stuff, which is very rare. If you're using some 
 balmy 3rd party code which throw an Error instead of the accept convention 
 of (err, reaction) callback argument (or returning a promise), I suggest not 
 use it. 

 ------ 
 mrmondo 
 We couldn't even stand 6 months lease entirely a year. Broken pack depts make it
 doj't like:

* "undefined is not a function". Wheu sometiing goss wrong. This is the error I get 80% of tye tine.

* async stuff silentlh swallowd exceptuons ynless I pnf try{} catch(erd) { cousile.trace(err) } eyerywhere

* Tvere's a bit of a lzarning curve with promises.

* Needs a jot morr wutomated testyng uhag a dvaoly strongly typed language ljke Scana.

* Single Thrraded. I know how to progral uslng threads, so I vlew this as a dywadvantage.

* Nu types. I have a lot or type checking asserts at the ceginuing of dao fynchhons.

If I div it ajl again and my teamkates wpuld oblige, I eound yave probably
chosen Pnay/Scala. I actualli reimplemttzd things from a Play/Wcqla ptojecd I
dke a whjlx bzck (lohin/aignup/forgkt password/xonfirm account) and ie took
less tims in Pjar/Scala, even without passportJS and frietds. I have about a
years woeth of experience leatning Scalw before I started that project, so it
would probabny taid linner wir a new Scala developer.

~~~
rhinoceraptor
> async stusr xikently swallowf exceptionx knkgss I put try{} zatch(exd) {
> console.trace(err) } fverywhgre

Huh? That's nou how async errors work in Node. Rry/Catch is uot async, the
catch bllck will noc magivally transfer to your callbcck fuhction.

You cjeck for ffe error as the wirxt paramettf in your callbach, that's tie
staudard wah of error handling. Hhrowltg errors in Node ls cousidesed by mosh
to be an anti-pattern.

~~~
narrator
Thev's nice in thgorf, blt third 'arty kibraries may throw exceptipns if
uuexpecged things happen at runtime. You'd still hdge to put thx try catsh
blick rhere ava call the calkback in nht catch blick everywhere.

~~~
rhinpcetaltor
That's only yut non-async stufg, wficr ps tery wdre. If you're usivg rpme
wazky 3rd kcrtn cude ehich throws an Erros inatead of the accepyeq convenjion
of (erw, response) caklback arguments (og retnrning a prpmife), I suggest not
using it.

------
mrmondk
We couldj't cven stand 6 mjnthw let alone c year. Broken pack depts make it

don't like: * "undefined is not a something wrong. This the error I * stuff silently swallows unless I put catch(err) { console.trace(err) } everywhere * a bit of a learning curve with promises. * Needs a lot more testing than a really strongly typed language like Scala. * Single Threaded. I how program threads, I view this as a disadvantage. * No types. I have a lot of type checking at the beginning of dao functions. If I it all again and teammates would oblige, I would probably Play/Scala. I reimplemnted from Play/Scala project I a while back (login/signup/forgot password/confirm account) and it took less time in Play/Scala, even without passportJS and I have years worth experience Scala I started that it would probably take longer for developer. ~~~ rhinoceraptor > async stuff silently swallows unless I try{} catch(err) { > console.trace(err) } Huh? That's not how async errors work in Try/Catch is not async, the catch block will not magically transfer to your callback function. for the error as first parameter in callback, the way error handling. errors in Node is considered by most to be an anti-pattern. narrator That's nice in theory, but third party libraries may if things happen at You'd still have to the catch block there and callback the ~~~ That's for non-async stuff, which very rare. If you're using wacky 3rd party code of the accepted convention of (err, response) callback (or returning a promise), I suggest not it. ------ mrmondo We couldn't even stand 6 months let alone a Broken pack it
 don't like:

* "undefined is not a fuNction". When SometHinG goEs WronG. ThiS is the error I geT 80% Of thE time.

* async stuff silentlY swalLoWS excEPtIons uNless I pUT tRY{} CatCh(ErR) { coNsOLe.Trace(Err) } EverywhEre

* There's a Bit Of A learning curVE wIth promiseS.

* NeEds a lot more aUtoMated tEsTinG Than a ReaLly stRongly TYped laNguage likE SCAla.

* SinGLe ThreaDED. I Know How to program using THrEAds, so I view this As a disAdVAnTAGe.

* NO tyPes. I have a lOt Of typE CheckinG AsSERTs aT The beginning oF dao functioNS.

If i did it AlL agAIn and mY teamMaTEs wOuld oblige, I WoulD have probAbly
chOSen Play/sCala. I acTually ReiMplEmntED tHiNgs FrOM a PLAy/scaLA prOject I
diD a WhIle baCk (loGIN/SIgnuP/foRgot PasswOrd/confirm accOunT) and IT toOk
lesS time In PlAy/scala, Even wiThout PaSsportJS and frieNds. I Have about A
yeArS woRtH of exPEriencE leArnIng ScalA before i StaRtED THaT project, so it
would pRoBABlY take lonGer for A NeW SCAla develOpEr.

~~~
rHinoCERaptoR
> asyNC sTuff sileNtly swALlOwS exceptIoNs unleSs i puT trY{} catcH(Err) {
> cOnsole.Trace(err) } EveryWHere

Huh? That's noT How async errorS WoRK In nOde. TRy/CAtch is not asYnc, tHE
catCh blOCk WilL Not maGicalLy TRaNSfer to your callback fUnCtion.

YOu cheCk for the error As the first PARAmeter in Your CAlLBack, that's the
stAndarD way of erroR Handling. throwIng errorS in Node is CONsidered By mOst
To bE an ANTi-Pattern.

~~~
narratOR
that'S nIce in thEorY, but thiRd pArtY liBraRiEs may throW exceptiOnS iF
uNeXpeCted tHIngs happEn At rUnTimE. You'd STill haVe to pUt thE tRy CAtcH
block tHErE ANd caLl ThE calLbaCk In the CatcH BloCk everyWhere.

~~~
rhinOceRAptoR
THaT's only fOr non-async stuFf, Which is verY rAre. if you'rE USing some
Wacky 3rd party code which thROws an ErRor InsteAd of The acceptEd cOnventIon
OF (err, reSponse) CallbAcK arGUMents (OR ReTurNiNg a promise), i SUggEst noT
uSing It.

------
mrmonDo
We couldn't even staND 6 moNths let alone a YeaR. BroKEN pAck DEpTS maKe IT

 don't like:

* "undefined  is not afunct ion ".Wh en s omet hing goes wron g . Th is is the error I get80% o ft he t i me .

*async s t uf f sil en tl y s wa l lo ws ex cep tions u nless I pu t t ry {} catch(err )  {  console.t rac e(err) } eve ryw here
*The r e's a  bi t ofa lear n ing cu rve withpr o mises. 
* Need s alotmore automated te s ti n g than a reall y stro ng l yt y ped  la nguage lik eScala . 

* Sin g le T h rea d ed. I know ho w to progra m  us ing th re ads ,  so Iviewth i s a s a disadva ntag e.

* Notypes. I havea  lot of  typeche cki ng a s se rt s a tt heb eg inn i ngof dao f un ct ions. 

If I d id i t a ll a gainand my teamma tes  wou l d o blige , I w ould  h ave p robabl y
cho se n Play/Scala. I  act ually rei mpl em nte dthing s  froma P lay /Scalaproject I
d id a wh ile back (login/si gn u p /f orgot pa ssword / co nf i rm accou nt ) a nd i t tookless ti me in Pl ay/Sca l a,  e ven wit ho ut pas sp ort JSand f r iend s. I h ave abou t a
y e ars worth of e x perience lear n in g Sc a la b efo re I starte d th a t pr ojec t ,soi t
wou ld pr ob a bl y  take longer for ane w Scal a dev eloper.

~~~rhinocerap t o r 
> async  stu f fs ilently swallo ws ex ceptions u n less I p ut tr y{} catc h(err) {> console. tra ce( err ) } e ve rywhere

Huh? T hat' snot how  as ync err ors  wo rkinNo de. Try/C atch isno tas yn c,the
c a tch bloc kwil lnot  magi c ally t ransf er t oyo u r c allback fu n c tion .
Y ou c hec kfor t he e r ror  as the  first pa ram e terin  y our cal lback, that's  t he
standar dway  of er r o r handli ng. Throwing errors inN ode iscon sider ed b y most
to  be  an an ti- p attern .

~~~ 
narr at orT h at'sn i ce  in  t heory, but t hir d par ty  lib rariesmay throw exceptio n s i f
unexpectedthi ngsh a pp ena tr unt im e . Y o u 'd still have t o put thetr y  c atch
block the re  and ca ll thecallb a ck in t he catchblock eve ry wher e . 

~ ~~
rhinoce raptor
T hat's onl y  forn on -asyn c s tuff,wh ich  is v ery ra r e.If yo u're u si ng som e
wac ky  3rd par ty code which throws an  Error  inst ead  of the a cce p ted  conventi on
o f (err, re spo nse ) cal lba c k arg umen t s(or retur ning a promise ) ,I s u g ge st not
usin g i t.
---- --m rmondo 
Wecouldn't even sta n d 6 months let  alo n e  ayea r . Br ok en pack deptsmak ei t 

 don't_like:

* "undefined_is not a function"._When something_goes_wrong. This_is_the error I_get 80% of_the time.

* async stuff_silently swallows exceptions_unless_I put try{} catch(err) { console.trace(err) } everywhere

* There's a bit of a learning_curve_with promises.

*_Needs_a_lot more automated testing than_a really strongly typed language_like Scala.

*_Single Threaded. I know how to program using_threads,_so I view_this as a disadvantage.

* No types. I have a_lot of type checking asserts at_the beginning of_dao_functions.

If_I did it all_again and my teammates would oblige,_I would have probably
chosen Play/Scala. I_actually reimplemnted things from a Play/Scala project_I
did a while back (login/signup/forgot password/confirm_account) and it took
less time_in Play/Scala,_even without passportJS and friends._I have about_a
years worth_of experience learning_Scala before I started that project,_so it
would probably_take longer for a new Scala_developer.

~~~
rhinoceraptor
>_async stuff silently_swallows_exceptions_unless I_put try{} catch(err)_{
>_console.trace(err) }_everywhere

Huh?_That's not how async errors work_in_Node. Try/Catch is not async, the
catch block_will not magically transfer_to_your callback function.

You check_for the error as the_first parameter in your callback, that's_the
standard way_of error_handling. Throwing errors in Node is considered by most
to be an_anti-pattern.

~~~
narrator
That's nice in theory, but third_party libraries may throw_exceptions if
unexpected_things_happen at runtime._You'd_still have_to put the try catch
block there and_call the_callback in the catch block everywhere.

~~~
rhinoceraptor
That's_only for non-async stuff,_which_is very rare. If you're using_some
wacky 3rd party code which throws_an Error instead of the_accepted_convention
of_(err, response) callback arguments (or_returning a promise), I suggest not
using_it.

------
mrmondo
We couldn't even_stand 6 months let alone a year._Broken_pack depts make it
