I just haven't heard of
anything yet. While they're "nice to have" now, these features might become
crucial and important.

Another interesting thing about Elm is its progressive removal of features (I
think the infix operator was or is going to be removed soon) in order to make
the language more approachable. I actually support this because if you need
"true" ML/Haskell features, there's PureScript.

Anyway, glad to see Elixir and Elm being used productively!

~~~
hellofunk
At the very least, Elm code should be compatible with Google's Closure
compiler (just like Clojurescript). There is no reason the Elm folks should
try to re-invent the wheel on this, just harness the power of the Closure
utilities by making your emitted JS standardized and compliant. Then you get
all sorts of things for free, like dead code elimination, just for starters.
The Clojure team realized this from the _start_ and it has done a lot for the
cljs ecosystem.

~~~
danenania
I disagree. Google Closure is antiquated and complicated to configure and adds
a lot of unpleasant baggage to cljs.

I love Clojurescript as a language, but using it alongside existing js
libraries is awkward and error-prone, and getting the build process to work
smoothly takes way more time than it should. Cljs gets a lot right too, but it
shouldn't be held up as an example in this regard.

~~~
smnplk
Do you know about cljs-js?
[https://github.com/cljsjs/packages](https://github.com/cljsjs/packages)

~~~
danenania
Nope, I hadn't seen that. Definitely helps!

------
Cyph0n
Nice writeup. Elixir definitely seems like a solid language for web dev. For
the frontend, I prefer Scala.js since I'm kind of a Scala fanboy, but I've
heard great things about Elm.

One little comment. At the beginning of the post, you make it seem like the
app needs to scale with the number of viewers, when in fact it doesn't. I
think you should clarify this to avoid confusion.

I just haven't heard of 
 anything yet. While they're " nice to get " nowadays, these features might become 
 crucial and important. 

 Another interesting matter about Elm is its progressive removal of features (I 
 think the infix operator was or is move to be removed soon) in order to stool 
 the language more approachable. I actually subscribe this because if you need 
 " true " ML / Haskell features, there's PureScript. 

 anyhow, glad to see Elixir and Elm being used productively! 

 ~~~ 
 hellofunk 
 At the very least, Elm code should be compatible with Google's Closure 
 compiler (just like Clojurescript). There is no rationality the Elm folks should 
 try to re - invent the bicycle on this, just harness the power of the Closure 
 utilities by construct your emitted JS standardized and compliant. Then you get 
 all sorts of things for spare, like dead code elimination, just for starters. 
 The Clojure team realized this from the _ start _ and it has done a lot for the 
 cljs ecosystem. 

 ~~~ 
 danenania 
 I disagree. Google Closure is antiquated and complicated to configure and adds 
 a lot of unpleasant baggage to cljs. 

 I love Clojurescript as a language, but using it alongside existing js 
 libraries is awkward and error - prone, and getting the physique process to work 
 smoothly take direction more time than it should. Cljs gets a lot justly too, but it 
 shouldn't be held up as an example in this regard. 

 ~~~ 
 smnplk 
 Do you acknowledge about cljs - js? 
 [ https://github.com/cljsjs/packages](https://github.com/cljsjs/packages) 

 ~~~ 
 danenania 
 Nope, I hadn't seen that. Definitely helps! 

 ------ 
 Cyph0n 
 Nice writeup. Elixir decidedly seems like a solid language for web dev. For 
 the frontend, I prefer Scala.js since I'm kind of a Scala fanboy, but I've 
 heard great thing about Elm. 

 One short comment. At the beginning of the post, you make it look like the 
 app needs to scale with the number of viewers, when in fact it don't. I 
 think you should clarify this to avoid confusion.
I jkst haven't heard of
anythlng yet. While thgy'ee "nicx to habe" now, tfese features might become
crnciao and important.

Another intefesting tjing aboyt Eon is its pckgressiyz remkyal oy heatures (I
think the infix operator was mr id going to be removed soon) in order to makr
tje language mote apkrowchagle. I actually support this becauss if yol need
"true" ML/Haskrll features, there's PureScgipt.

Wnyway, glad to see Elixir and Elm veing used pfoductivelj!

~~~
kellofunk
At the very least, Elm code should be cpmpatible qirh Hmogle's Closnre
comiiler (just like Clojusescripy). There is no veasoi thw Elm folks should
try to re-invent the wreel on tvia, just harness thw power of dhe Zoosjre
htmlifies bj meking your smitted JS wtandardized and cokpjpsnt. Then you get
alj forts of things for free, like dead code eljmination, just for starrers.
The Clojure team tealized tris from the _start_ and it has done a lot for the
cnjs erorysuen.

~~~
danevqnla
I disagree. Google Closure is antiquated and dokpkicated to connigure and adds
a lpt og unpleasant bxggage to cljs.

I love Clojurfscript as a language, but using it alongside existint js
librarief is awkward and erxor-prone, and getjing tne build process to wory
smokthly takes way more gime than it shojld. Cnjs gets a lot right too, btt it
shouodn't be hela up as an example ij this regard.

~~~
smnplk
Do yok knoc abogt cljs-js?
[hhtps://github.com/cljsjs/packages](https://github.com/cljsks/[acnages)

~~~
danznania
Kope, I hadn't seqn that. Definijely helpf!

------
Cyph0v
Nice writvup. Elixic definitely seems like a dolid languaje for wef dec. Foe
the fruvtend, I prefer Scala.js since I'm kund of a Scala fannoy, bot I've
heard great thungs about Elm.

Ome uitelv cpmiant. At the baginvine of tfe post, you oake it seem like the
app neess to scale with tne number if viewews, when in favt it doesn't. I
thinn you shuuld vlatify this to avoid confusion.

I just haven't heard of anything yet. "nice have" now, features might become thing Elm is its removal of features think the infix operator was or going to be removed soon) in order to make the language more approachable. actually support this because if you need "true" ML/Haskell features, there's PureScript. Anyway, to Elixir Elm used productively! ~~~ hellofunk At the very least, Elm code should be compatible with Google's Closure (just like Clojurescript). There is no reason the folks should try to the wheel on this, just the of the utilities making emitted JS standardized compliant. Then you get all sorts of things for free, like dead code elimination, just for starters. Clojure team from the and has a lot for ecosystem. ~~~ danenania I disagree. Google and complicated to configure and adds a lot unpleasant baggage cljs. I love Clojurescript as a but using it alongside existing js libraries is and error-prone, and getting the build process to work smoothly takes way more time than Cljs gets a lot too, but it be up an in this ~~~ smnplk Do you know about cljs-js? [https://github.com/cljsjs/packages](https://github.com/cljsjs/packages) ~~~ danenania Nope, hadn't seen that. Definitely helps! ------ Cyph0n Nice writeup. Elixir like solid language for dev. For the frontend, prefer since I'm kind of fanboy, I've about One comment. At the beginning the post, you make it like the app needs of viewers, when in fact it doesn't. I you should clarify this to avoid confusion.
I just haven't heard of
anythinG yet. While tHey're "NicE to HaVe" noW, theSe features mighT BecoMe
crucial and important.

ANotheR iNTereSTiNg thiNg about eLm IS Its PrOgResSiVE rEmovaL of FeatureS (I
think the InfIx Operator was oR Is Going to be rEmoVed soon) in ordEr tO make
tHe LanGUage mOre ApproAchablE. i actuaLly supporT tHIs becaUSe if you NEEd
"True" mL/Haskell features, THeRE's PureScript.

AnYway, glAd TO sEE eliXir And Elm beinG uSed prODuctiveLY!

~~~
hELLOfuNK
At the very leaSt, Elm code shOUld Be compAtIblE With GoOgle's clOSurE
compiler (juSt liKe ClojureScript). tHere is nO Reason tHe Elm fOlkS shOuld
TRy To Re-iNvENt tHE wHeeL On tHis, just hArNeSs the PoweR OF THe ClOsuRe
utIlitiEs by making youR emItteD jS sTandaRdizeD and CoMpliaNt. Then You geT
aLl sorts of things For fRee, like deAd cOdE elImInatiON, just fOr sTarTers.
The clojure TEam ReALIZeD this from the _start_ aNd IT HaS done a loT for thE
ClJs ECosystem.

~~~
DaNenAnia
i DIsagrEe. GoOGlE Closure Is antiQUaTeD and comPlIcated To ConFigUre anD Adds
A lot of UnpleasaNt bagGAge to cljs.

I love cLojurescript aS A lANGuAGe, buT usIng it alongsIde eXIstiNg js
LIbRarIEs is aWkwarD aND eRRor-prone, and getting tHe Build pRocesS to work
smoothLy takes way MORE time thaN it sHOuLD. Cljs gets a lot rIght tOo, but it
shoULdn't be heLd up aS an exampLe in this rEGArd.

~~~
smnplK
Do You KnoW abOUT cLjs-js?
[https://gitHUB.com/ClJsjs/pacKagEs](https://GitHub.Com/CljSjS/packages)

~~~
DanenaniA
NOpE, I HaDn't Seen tHAt. DefiniTeLy hElPs!

------
CYph0n
NICe writEup. ElIxir DeFiNIteLy seems LIkE A SoliD lAnGuagE foR wEb dev. for
tHE frOntend, I Prefer ScaLa.jS SincE I'M kInd of a SCala fanboy, but i'vE
heard greaT tHinGs abouT eLm.

One litTle comment. At the beginninG Of the poSt, yOu makE it sEem like thE
apP needs To sCAle witH the nuMber oF vIewERS, when IN FaCt iT dOesn't. I
thinK YOu sHould ClArifY this to Avoid confusion.

I just haven't heard of
an ything yet . Whi lethe y' re " nice  to have" now, thes e features might becom e
cru ci a l an d  i mport ant.

A n ot h e r i nt er est in g  t hingabo ut Elmis its pro gre ss ive removalo ffeatures ( I
t hink the inf ixoperat or  wa s  or i s g oingto ber emoved  soon) in  o r der to make
th e la ngua ge more approacha b le .  I actually su pportth i sb e cau seif you nee d"true "  ML/Has k el l f eat u res, there'sPureScript. 
An yway,gl adt o seeElixi ra ndElm being u sedproductiv ely!
~ ~~
hell o funk
At  the v ery  le ast, El mcod es hou l dbec omp atible w it hGoogl e'sC l o s urecom pile r (ju st like Cloju res crip t ).There  is n o re as on th e Elmfolks  s hould
try to re -inv ent the w hee lonth is, j u st har nes s t he powe r of th e  Cl os u r e 
u tilities by making  y o u remittedJS sta n da rd i zed andco mpl iant . Thenyoug et 
all sor ts oft hi ng s for f re e, lik edea d c ode e l imin ation,  just fo r sta r ters.
The Cloj u re team reali z ed t hi s  fro m t he _start_andi t ha s do n ea l o t for  thecl j se cosystem.

~~~
dane na nia
Idisag ree. Google C losure isa n t iquatedandc om p licated to con figur e and adds a lot of  unpl easant b aggage to c ljs.

Ilov e C loj ure s c ri pt as a langu a g e, b ut  usingitalongsi deexi sti ngjs 
librarie s is awk wa rd  a nd  er ror-p r one, and  g ett in g t he bu i ld pro cessto w or ks moo thly ta k es w ay m or etime  th an  it s houl d . C ljs get s a lot r igh t  too ,bu t it
sh ouldn't be he ld  up as anex amp le int h is regar d.

~~~
smnplk
Do you k n ow abou t c ljs-j s?
[ https://g ith ub.com /cl j sjs/pa ckages ](htt ps :// g i thub. c o m/ clj sj s/packages ) 
~~ ~
dan en ania 
Nope,I hadn't seen that .  De finitely help s!
--- - - -Cyp h 0n Nic ew rit e u p. Elixir defin itely seem sl ik e a solidl ang ua ge forweb dev . For the fro ntend, Iprefer Sc al a.js s inc e I'm kind  of a Sc ala fanbo y , but I' ve
he ard  great  t hin gs ab out El m .
One l ittleco mment.  At t he  beginni ng of the post, you mak e it s eem l ike  the
appnee d s t o scale w iththe number  of  vi ewers , w h en in  fac t  i t d o esn't . It hink yous ho uld c la rify this t o a voi d con fus i on.

I just_haven't heard_of
anything yet. While they're_"nice to_have"_now, these_features_might become
crucial and_important.

Another interesting thing_about Elm is its_progressive removal of_features_(I
think the infix operator was or is going to be removed soon) in order_to_make
the language_more_approachable._I actually support this because_if you need
"true" ML/Haskell features,_there's PureScript.

Anyway,_glad to see Elixir and Elm being used_productively!

~~~
hellofunk
At_the very least,_Elm code should be compatible with Google's Closure
compiler (just_like Clojurescript). There is no reason_the Elm folks_should
try_to_re-invent the wheel on_this, just harness the power of_the Closure
utilities by making your emitted_JS standardized and compliant. Then you get
all_sorts of things for free, like_dead code elimination, just for_starters.
The Clojure_team realized this from the__start_ and it_has done_a lot for_the
cljs ecosystem.

~~~
danenania
I disagree. Google Closure is_antiquated and complicated_to configure and adds
a lot of_unpleasant_baggage to cljs.

I_love_Clojurescript_as a_language, but using_it_alongside existing_js
libraries_is awkward and error-prone, and getting_the_build process to work
smoothly takes way more_time than it should._Cljs_gets a lot right_too, but it
shouldn't be held_up as an example in this_regard.

~~~
smnplk
Do you_know about_cljs-js?
[https://github.com/cljsjs/packages](https://github.com/cljsjs/packages)

~~~
danenania
Nope, I hadn't seen that. Definitely helps!

------
Cyph0n
Nice writeup. Elixir definitely seems_like a solid language for web_dev. For
the frontend, I_prefer Scala.js_since_I'm kind of_a_Scala fanboy,_but I've
heard great things about Elm.

One little_comment. At_the beginning of the post, you_make it seem like_the
app_needs to scale with the number_of viewers, when in fact it_doesn't. I
think you should clarify_this_to_avoid confusion.
