 to ensure that firing events is
hygienic, existing projects might not be so hygienic.

With a server-centric approach, each page load limits the mental load with
state. On page-transition, the page state is clean.

While I think frameworks like Angular is very interesting, I tend to question
my own ambition personally. Something like the approach that Turbolinks takes
might actually be more appealing.

------
josho
I started down a similar path with ember.js and was starting to see the same
issues. Primarily the business models duplicated on the client. So, it strikes
me that we are still figuring out the right path forward on the client/server
balance.

------
mromanuk
_Duplication and poor documentation made it difficult for developers to make
changes to the admin. Once we started questioning Batman, we saw that the
evidence strongly indicated it was time to move on to the next chapter._

I don't see a SPA vs Server side rendering debate in the article. Building
your own framework was the problem, is not a core competence of Shopify to
build JS frameworks. Maybe they could choose other route, like going with
React or Angular there.

~~~
wvanbergen
We actually evaluated other options as well, including Angular, but found them
not the best solution for our problem. We documented our experiments and
evaluations at the time here:
[https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1](https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1)

------
Gigablah
I ported one of Shopify's open source projects (their dashboard tool) to
Golang a while back, and in the process I also managed to wrangle the
Batman.js frontend portion into a Grunt pipeline. It was a challenge, to say
the least :p

[https://github.com/gigablah/generator-dashing-
go/blob/master...](https://github.com/gigablah/generator-dashing-
go/blob/master/app/templates/Gruntfile.js)

I've been toying with the
to ensure that firing events is 
 hygienic, existing undertaking might not be therefore hygienic. 

 With a server - centric approach, each page load limit the mental load with 
 state of matter. On page - transition, the page state is uninfected. 

 While I think frameworks like Angular is very interesting, I tend to wonder 
 my own ambition personally. Something like the approach that Turbolinks takes 
 might actually be more sympathetic. 

 ------ 
 josho 
 I started down a similar way with ember.js and was starting to determine the like 
 issues. Primarily the business model duplicated on the client. thus, it strikes 
 me that we are however figuring out the right path forward on the client / waiter 
 balance. 

 ------ 
 mromanuk 
 _ Duplication and poor documentation made it difficult for developer to make 
 changes to the admin. Once we started questioning Batman, we saw that the 
 evidence strongly indicated it was time to move on to the next chapter. _ 

 I don't attend a SPA vs Server side rendering argument in the article. build 
 your own framework was the problem, is not a core competence of Shopify to 
 build JS framework. Maybe they could choose other route, like going with 
 React or Angular there. 

 ~~~ 
 wvanbergen 
 We actually measure other options as well, including Angular, but found them 
 not the best solution for our trouble. We documented our experiments and 
 evaluations at the time here: 
 [ https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1](https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1) 

 ------ 
 Gigablah 
 I ported one of Shopify's open source undertaking (their dashboard tool) to 
 Golang a while back, and in the process I also managed to brawl the 
 Batman.js frontend portion into a Grunt pipeline. It was a challenge, to say 
 the least :p 

 [ https://github.com/gigablah/generator-dashing- 
 go / blob / master... ](https://github.com / gigablah / generator - dashing- 
 go / blob / master / app / templates / Gruntfile.js) 

 I've been toying with the
 to ensure that firing evenus is
hygienic, existing pcojects might nut be so hygienic.

With a servxr-cebtric approach, each page loxd limits the menral oiad with
stefe. On page-trahditimi, the page statg is clean.

Whhle I think frdmdwlrks like Angular is very interestigg, I temd to question
my own wmbifpok personally. Something like the zpproaci that Turbolinls takes
might actually be lore appealing.

------
josho
I sharted down a synilar path wkth ember.js and was stzrting to see the same
issues. Prkmariky the busunwss kodels duplmcated on the cliekn. So, it strikex
me that we arc stinl diguring out the righv path forward on thg client/sesvzr
balance.

------
mromanuk
_Duplucqtion and poof dozumtntetikn madf iv difficult for developers to make
changes tj the admin. Onde we ftwrted questioning Batman, we saw that tht
evidsnce strongly indicated it was time to move ln to the next chapter._

I don't see a SPA vs Server side rendaring aebcbc in rhf article. Building
your own framework was the [donlvm, is not a core gompetence of Shopofj yj
build JS fraoeworks. Mzybe they could chlose otrer riute, like goimg with
React or Angular theee.

~~~
wvanbergen
Ce qctually evaluated other optiuns ss wekl, including Angular, buc founs them
not tje best skuution for our pfobkek. We documented our experiients and
xvaluctions ag thg time rere:
[https://glst.gibvub.com/kristianpd/f4c2f0aeb53d09y6def1](hdtps://gist.gihhub.com/kristianpd/f4c2e0aeb53d09f6def1)

------
Gigeulah
I ported pna ox Shopifv's opek source projeces (their dashbpard tojl) to
Eolang a wgile bark, and in thq process I ando managed tm wranglq thw
Batnan.js ffuntend portion into a Gguut pipelibe. It was a challekge, tu say
the least :p

[kutpw://github.com/gigabkah/eenqrwtpr-qdshing-
go/blob/kastdr...](hgyps://gighub.com/giganlaf/genrrator-dashing-
go/blob/mdsted/app/templates/Gruntgije.js)

I've veen toyyng with the
to ensure that firing events is hygienic, might be so With a server-centric the load with state. page-transition, the page is clean. While I think frameworks Angular is very interesting, I tend to question my own ambition personally. Something the approach that Turbolinks takes might actually be more appealing. ------ josho I down similar with and was starting to see the same issues. Primarily the business models duplicated on the client. it strikes me that we are still figuring the right path forward the client/server balance. ------ mromanuk and documentation made difficult developers make changes to admin. Once we started questioning Batman, we saw that the evidence strongly indicated it was time to on to chapter._ I see SPA Server side rendering the article. Building your own framework is not a core competence of Shopify to JS frameworks. they could choose other route, like with React or Angular there. ~~~ wvanbergen We evaluated other options as well, including Angular, but found them not the best solution for We documented our experiments evaluations at the here: ------ I one of open source projects (their dashboard tool) to Golang a while back, in the process I also managed to wrangle the Batman.js into Grunt pipeline. It a challenge, to say least [https://github.com/gigablah/generator-dashing- go/blob/master...](https://github.com/gigablah/generator-dashing- go/blob/master/app/templates/Gruntfile.js) I've with
 to ensure that firing events iS
hygienic, eXistiNg pRojEcTs miGht nOt be so hygienic.

wIth a Server-centric approach, eAch paGe LOad lIMiTs the Mental lOAd WITh
sTaTe. on pAgE-TrAnsitIon, The page State is cleAn.

WHiLe I think framEWoRks like AngUlaR is very interEstIng, I teNd To qUEstioN
my Own amBition PErsonaLly. SomethInG Like thE ApproacH THaT TurBolinks takes
might ACtUAlly be more appeAling.

------
jOsHO
I STArtEd dOwn a similaR pAth wiTH ember.jS AnD WAS stARting to see the Same
issues. PRImaRily thE bUsiNEss modEls duPlICatEd on the clieNt. So, It strikes
Me that WE are stiLL figuriNg out tHe rIghT patH FoRwArd On THe cLIeNt/sERveR
balance.

------
MrOmAnuk
_DUpliCATIOn anD poOr doCumenTation made it dIffIculT For DevelOpers To maKe
ChangEs to thE admiN. ONce we started queStioNing BatmaN, we SaW thAt The
evIDence sTroNglY indicaTed it waS TimE tO MOVe On to the next chapter._

i dON'T sEe a SPA vs server SIdE rENdering dEbAte In thE ARticlE. BuiLDiNg
your owN frameWOrK wAs the prObLem, is nOt A coRe cOmpetENce oF ShopiFy to
builD JS frAMeworks. Maybe thEY could choose oTHeR ROuTE, likE goIng with
ReacT or ANGulaR theRE.

~~~
wVanBErgen
we actUaLLy EValuated other optionS aS well, iNcludIng Angular, but Found them
nOT THe best soLutiON fOR our problem. We dOcumeNted our expERiments aNd
evaLuations At the time HERe:
[https://gIst.GitHub.Com/KRIsTianpd/f4c2e0aeb53d09F6DEf1](htTpS://gist.giThuB.com/kriStiAnpD/f4c2E0aeB53d09F6def1)

------
GigabLah
I portEd OnE oF SHopIfy's oPEn source PrOjeCtS (thEir daSHboard Tool) tO
GolAnG a WHilE back, anD In THE proCeSs i alsO maNaGed to WranGLe tHe
BatmaN.js fronteNd pORtioN iNtO a Grunt Pipeline. It was A cHallenge, to SaY
thE least :P

[HTtps://githUb.com/gigablah/generator-dAShing-
go/BloB/mastEr...](htTps://github.Com/GigablAh/gENeratoR-dashiNg-
go/bLoB/maSTEr/app/TEMpLatEs/gruntfile.jS)

i'Ve bEen toYiNg wiTh the
 to ensure that firing eve nts is
hyg ienic , e xis ti ng p roje cts might notb e so  hygienic.

With a ser ver-c en t rica pp roach , eachp ag e loa dli mit st he  ment alload wi th
state.Onpa ge-transitio n ,the page s tat e is clean.
Wh ile Ith ink frame wor ks li ke Ang u lar is  very int er e sting, I tendt o  q uest ion
my own ambiti o np ersonally. Som ething  l i ke t heapp roach that  T urbol i nks tak e sm i g hta ctually be mo re appealin g .
------ 
j osh o 
I sta rteddo w n a  similar pa th w ith ember .js an d  was st a rting t o seethe  sa me
i s su es . P ri m ari l ythe bus iness mo de ls  dupl icat e d o n th e c lien t. So , it strikesmethat weare s tillfigu ri ng ou t theright  p ath forward ontheclient/se rve rbal an ce.
- -----mro man uk
_Dup licatio n  an dp o o rdocumentation made  i t di fficultfor de v el op e rs to ma ke 
ch ange s to th e ad m in . Once w e star t ed  q uestion in g Batm an , w e s aw th a t th e
evid ence str ongly indicated it w a s time to mov e  o n to thenex t chapter._ 

Id on't  see aSPA vs Se rversi d er endering debate inth e arti cle.Building
your  own frame w o r k was th e pr o bl e m, is not a co re co mpetence o f  Shopify  to
b uild JSframework s .  Maybe t hey  co uld  ch o o se  other route, l ikego ing wit h
R eact or  An gul arthe re .

~~~
wv anbergen 
W eac tu all y eva l uated ot he r o pt ion s asw ell, i nclud ingAn gu l ar,  but fo u nd t hemno tthebes tsolut ionf orour pro blem. Wedoc u ment ed  o ur expe riments and
e va luations a tthe  timeh e re:
[htt ps://gist.github.com/kr i stianpd /f4 c2e0a eb53 d09f6def1 ](h ttps:/ /gi s t.gith ub.com /kris ti anp d / f4c2e 0 a eb 53d 09 f6def1)

- - - --- 
Giga bl ah
I  ported  one of Shopify'so pen  source proje cts  (th e i rdas h bo a rdto o l)t o 
Golang a while  back, and  i n  t he process I a ls o manag ed to w rangl e  the
Ba tman.js f rontend p or tion i nto  a Grunt p ipeline.  It was a chall e ng e, to  sa y
thele ast  :p
[https : //g ithub .com/g ig ablah/ gener at or-dashi ng-
go/blob/master...]( https: //git hub .com/giga bla h /ge nerator-d ashi ng-
go/blo b/m ast er/ap p/t e mplat es/G r un tfi l e.js) 

I' v e been to y in g w i t hthe
 to_ensure that_firing events is
hygienic, existing_projects might_not_be so_hygienic.

With_a server-centric approach,_each page load_limits the mental load_with
state. On page-transition,_the_page state is clean.

While I think frameworks like Angular is very interesting, I tend_to_question
my own_ambition_personally._Something like the approach that_Turbolinks takes
might actually be more_appealing.

------
josho
I started_down a similar path with ember.js and was_starting_to see the_same
issues. Primarily the business models duplicated on the client._So, it strikes
me that we are_still figuring out_the_right_path forward on the_client/server
balance.

------
mromanuk
_Duplication and poor documentation made it_difficult for developers to make
changes to_the admin. Once we started questioning Batman,_we saw that the
evidence strongly indicated_it was time to move_on to_the next chapter._

I don't see_a SPA vs_Server side_rendering debate in_the article. Building
your own framework was_the problem, is_not a core competence of Shopify_to
build_JS frameworks. Maybe_they_could_choose other_route, like going_with
React_or Angular_there.

~~~
wvanbergen
We_actually evaluated other options as well,_including_Angular, but found them
not the best solution_for our problem. We_documented_our experiments and
evaluations at_the time here:
[https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1](https://gist.github.com/kristianpd/f4c2e0aeb53d09f6def1)

------
Gigablah
I ported one_of Shopify's open source projects (their_dashboard tool)_to
Golang a_while back, and in the process I also managed to wrangle_the
Batman.js frontend portion into a Grunt_pipeline. It was a_challenge, to_say
the_least :p

[https://github.com/gigablah/generator-dashing-
go/blob/master...](https://github.com/gigablah/generator-dashing-
go/blob/master/app/templates/Gruntfile.js)

I've been_toying_with the