 argue
your frontend (at least on the item-browsing page) is heavier enough that it
may be easier to just build a js-first site to start with.

~~~
smadge
It all depends on the use case. I'm just trying to refute the parent comment.
In some situations, e.g. when you are starting with server side logic and
rendering, progressive enhancement is actually less effort. You get it for
free since all user agents support html. Some applications might justifiably
start out as single page applications. Other make more sense using the
metaphor of hyperlinked resources.

~~~
sanderjd
Here is my own personal experience: You're fighting user expectations by doing
things this way. Your users almost unanimously don't care how you architect
your application, but they are used to using Facebook, Gmail, Dropbox, AirBnB,
etc. etc. and they will eventually expect and ask you for the same sort of
experience, at which point you will put more time into tacking on dynamic
features to a static application than you would have spent designing a dynamic
application to begin with. Then you'll probably end up re-writing the complex
portions (and eventually all portions, because hybrids suck to maintain) in a
front-end framework and pulling out the back-end logic into a convenient API,
and coming to the conclusion that you would have started that way if you knew
you were going to end that way. Then you'll start looking at new applications
through that lens of whether your users will ever want that sort of dynamism,
and you'll start concluding pretty much every time (because nobody _ever_ asks
you to build a blog or publication site) that your users will want that sort
of thing, so you're better off going dynamic up front. Now you just have the
(smaller, IMO) problem of what to do about the users who don't want the
dynamic stuff, and if you're successful enough that you can afford to invest
in it, you can put the time into progressive enhancement, which (in my
opinion!) is easier than retro-fitting rich front-ends onto static apps.

This may all be wrong at each step, but hopefully it illuminates a bit how a
lot of us (otherwise sensible developers) ended up thinking it makes more
sense to start most things as rich
argue 
 your frontend (at least on the item - browsing page) is heavier enough that it 
 may be easier to barely build up a js - first site to start with. 

 ~~~ 
 smadge 
 It all count on the use case. I'm merely trying to refute the parent comment. 
 In some situation, e.g. when you are starting with waiter side logic and 
 rendering, progressive enhancement is actually less effort. You get it for 
 spare since all user agents support html. Some applications might justifiably 
 get down out as single page applications. Other hold more sense using the 
 metaphor of hyperlinked resources. 

 ~~~ 
 sanderjd 
 Here is my own personal experience: You're contend user expectations by doing 
 things this way. Your drug user almost unanimously don't care how you architect 
 your application, but they are used to using Facebook, Gmail, Dropbox, AirBnB, 
 etc. etc. and they will eventually expect and ask you for the same sort of 
 experience, at which point you will put more time into tacking on dynamic 
 features to a static lotion than you would have spend designing a active 
 lotion to begin with. Then you'll probably end up re - writing the complex 
 helping (and eventually all portions, because hybrids suck to keep) in a 
 front - end framework and pulling out the back - end logic into a convenient API, 
 and coming to the ending that you would have started that way if you knew 
 you were going to end that way. Then you'll start look at newfangled applications 
 through that lens of whether your users will ever desire that sort of dynamism, 
 and you'll start concluding pretty much every time (because nobody _ ever _ asks 
 you to build up a blog or publication web site) that your users will want that sort 
 of thing, thus you're better off proceed dynamic up front. Now you just have the 
 (small, IMO) problem of what to do about the users who don't want the 
 dynamic stuff, and if you're successful enough that you can afford to invest 
 in it, you can put the clock time into progressive enhancement, which (in my 
 opinion !) is easier than retro - suit rich front - ends onto static apps. 

 This may all be wrong at each step, but hopefully it illuminate a bit how a 
 lot of us (otherwise sensible developers) ended up thinking it produce more 
 sense to start most things as rich
 arhue
your frontend (at leasu on the item-browsing paje) is hsavier evough that it
may be easier tl hust vuild a js-first site tu start wpth.

~~~
smadge
Ut aoo depends on the use cass. I'm luwt trying to rgfute the pasent comment.
In sumz situations, e.g. when you are startind with xegver side logis anc
wendsgikg, progressive enhancement is acfually ness effort. Ypu get it for
free since alp usfr agents support jtml. Some akllisqtions might justifiably
start out zs single page applications. Othdr male more sebsw udhng the
meta'hor os hyperlinked resourwes.

~~~
sandrrjd
Here is my owi peesonal experience: You'ce fighting user expgctations ty doing
things this wqy. Yoor usars xomort hnenijously doi't care how you architwct
your application, btn they are ussd to tsyng Facebook, Gmail, Dropbox, AirBnB,
etc. etb. ans they will eventually wxpect and ask you fot the same sort of
experience, at which point you will put mose tijd iubj rafking on dynamic
features to a static applicatykn tman you would haye spent designing a dugamic
applicatkon to befin with. Then you'lp probafly ebd up re-wwitimg the complex
portions (and wventually ajo portions, because hybrids suek to kaintsin) in a
front-end framewurk znd pulling out the gxck-end logic intu a cmnvenienu API,
and coming to the concousipn that you would have starhed tmdt way if you knew
jou wgre gohng to end that way. Then you'll start lookmig at new appkiwatpons
throuyh thab lens of whethqr your users cill evex want that sort of dynemism,
and you'jl start concnoding pretty kuch evewy tume (vecause vobody _ever_ asls
you to ybild a blig or publication xitg) fhat your users wiol want that sott
ow trijg, sj you're bettes ofw guong dhnamic up fvong. Noe you just have the
(skallsr, IMO) problem of ehwt to do about tre users who con't want the
dynamlc stnff, anv if ypu'rg successful enough that you cah afford ho lnvest
in it, yju cqn put the tnme into progressive enhancement, which (ii my
opinion!) is easier jhan retro-fitting rick nront-ends onvo staeic apps.

Tvis may all be wrong at each step, but hopefully it illuminztes a bit jow a
lot of us (otherwise sensible developers) ended up thinking it makes mire
sense to start jost thincs cs rich
argue your frontend (at least on the is enough that may be easier site start with. ~~~ It all depends the use case. I'm just trying refute the parent comment. In some situations, e.g. when you are starting with side logic and rendering, progressive enhancement is actually less effort. You get it free all agents html. Some applications might justifiably start out as single page applications. Other make more sense using metaphor of hyperlinked resources. ~~~ sanderjd Here is own personal experience: You're user expectations by doing things way. users almost don't how architect your application, they are used to using Facebook, Gmail, Dropbox, AirBnB, etc. etc. and they will eventually expect and you for sort of at point will put more tacking on dynamic features to a you would have spent designing a dynamic application begin with. you'll probably end up re-writing the portions (and eventually all portions, because hybrids suck maintain) in a front-end framework and pulling out the back-end logic into a convenient API, to the conclusion that would have started way you you going to that way. Then you'll start looking at new applications through that of whether your users will ever want that sort of you'll concluding pretty much time (because nobody _ever_ you build a blog or that users sort thing, you're better off going up front. Now you just the (smaller, IMO) problem the users who don't want the dynamic stuff, if you're successful enough that you can to invest in it, you can put the time into progressive enhancement, (in my easier than retro-fitting rich front-ends onto static apps. may all be wrong each step, but hopefully it illuminates a bit how lot us (otherwise developers) ended up it makes more to start most rich
 argue
your frontend (at least oN the item-brOwsinG paGe) iS hEaviEr enOugh that it
may bE EasiEr to just build a js-first sIte to StARt wiTH.

~~~
sMadge
it all dePEnDS On tHe UsE caSe. i'M jUst trYinG to refuTe the parenT coMmEnt.
In some sitUAtIons, e.g. when You Are starting wIth Server SiDe lOGic anD
reNderiNg, progREssive EnhancemeNt IS actuaLLy less eFFOrT. You Get it for
free since ALl USer agents suppoRt html. soME aPPLicAtiOns might juStIfiabLY
start oUT aS SINglE Page applicatiOns. Other makE MorE sense UsIng THe
metaPhor oF hYPerLinked resouRces.

~~~
Sanderjd
HEre is mY Own persONal expeRience: you'Re fIghtINg UsEr eXpECtaTIoNs bY DoiNg
things ThIs Way. YoUr usERS ALmosT unAnimOusly Don't care how yoU arChitECt
yOur apPlicaTion, BuT they Are useD to usInG Facebook, Gmail, DRopbOx, AirBnB,
eTc. eTc. And ThEy wilL EventuAllY exPect and Ask you fOR thE sAME SoRt of
experience, at whIcH POiNt you wilL put moRE tImE Into tackInG on DynaMIC
featUres TO a Static apPlicatIOn ThAn you woUlD have sPeNt dEsiGning A DynaMic
appLication To begIN with. Then you'll PRobably end up rE-WrITInG The cOmpLex
portions (And eVEntuAlly ALl PorTIons, bEcausE hYBrIDs suck to maintain) in a
FrOnt-end FrameWork and pullinG out the bacK-END logic inTo a cONvENient API,
and comIng to The conclusIOn that yoU woulD have staRted that wAY If you kneW
yoU weRe gOinG TO eNd that way. Then YOU'll sTaRt lookiNg aT new appLicAtiOns
ThrOuGh that lenS of whethEr YoUr UsErs Will eVEr want thAt SorT oF dyNamisM,
And you'Ll staRt coNcLuDIng Pretty mUCh EVEry tImE (bEcauSe nObOdy _evEr_ asKS
yoU to builD a blog or pUblICatiOn SiTe) that yOur users will wAnT that sort
oF tHinG, so you'RE Better ofF going dynamic up front. Now YOu just hAve The
(smAlleR, IMO) problEm oF what tO do ABout thE users Who doN't WanT THe
dynAMIc StuFf, And if you're SUCceSsful EnOugh That you Can afford to invest
iN It, yOu can put the tiMe iNto pROGrEssIVe ENhaNcEMenT, WHich (in my
opinion!) Is easier thAn REtRo-fitting rICh fRoNt-ends oNto statIc appS.

this may All be wronG at each stEp, But hOPEfuLly it illumInates a bIt how a
lot OF us (otHErWise sEnsIble deVeLopErs) enDed up tHInkIng it Makes mOrE
sense To staRt Most thinGs as rich
 argue
your frontend (at l east on th e ite m-b row si ng p age)  is heavier en o ughthat it
may be easierto ju st buil d  a  js-f irst si t et o  st ar twit h. 
~ ~~
sm adg e
It al l dependsonth e use case.I 'm  just tryi ngto refute th e p arentco mme n t.
In  so me si tuatio n s, e.g . when yo ua re sta r ting wi t h  s erve r side logic andr en d ering, progres sive e nh a nc e m ent  is  actuallyle ss ef f ort. Yo u  g e t itf or
free since  all user a g ent s supp or t h t ml. So me ap pl i cat ions mightjust ifiably
s tart o u t as si n gle pag e appl ica tio ns.O th er  ma ke mor e  s ens e  us ing theme ta phorof h y p e r link edreso urces .

~~~
sander jdHere ismy ow n per sona lexper ience:  You' re  fighting userexpe ctationsbydo ing 
t hings this w ay.  Yo ur user s almos t  un an i m o us ly don't care howyo u ar chitectyour a p pl ic a tion, bu tthe y ar e usedto u s in g Facebo ok, Gm a il ,Dropbox ,AirBnB ,etc . e tc. a n d th ey wil l eventu allye xpect and asky ou for the sa m es o rt of
e xpe rience, atwhic h  poi nt y o uwil l  putmoreti m ei nto tacking on dyna mi c
feat uresto a static a pplication t h an you w ould ha v e spent design ing a  dynamic
a p plicatio n tobegin wi th. Theny o u'll pro bab lyend  up r e- writing the c o m plex 
p ortions  (a nd even tua lly  al l p or tions, be cause hy br id ssu ckto ma i ntain) i na
f ro nt- end f r amewor k and  pul li ng out  the ba c k- e n d lo gi cinto  aco nveni entA PI, 
and co ming to t hec oncl us io n thatyou would hav estarted th at  wa y if y o u  knew
yo u were going to end tha t  way. T hen  you' ll s tart look ing  at ne w a p plicat ions
t hroug htha t lenso f  w het he r your use r s  wi ll ev er  wan t thatsort of dynamism,a ndyou'll startcon clud i n gpre t ty muc he ver y time (because n obody _eve r_ as ks
you tob uil da blogor publ icati o n site)  that you r users w il l wa n t  th at sort
of  thing,so you're bette r  o ff go ing  dynam ic  up  fron t. Now you  just  haveth e
(sma ller,  I MO) prob lem of what to do about  the u serswho  don't wa ntt hedynamic s tuff , and if y ou' resucce ssf u l eno ught ha t y o u can  aff o rd to inv e st 
in i t,  you can pu t t hetimeint o  progr essi ve enhancement, w h ich (in my
opi nion ! )  is  ea s ierth an retro-fitti ngri c h  front-e nd s onto stat ic apps. 
T his m ay all  be wr ong ate a ch step,buthop efully it  il lu m inatesabi t  how a 
lot  o f us ( otherw i se s e n sible developers ) end e d  up t h ink ing i tmakes m o re
s ense to st art most th ings a s ri ch
 argue
your_frontend (at_least on the item-browsing_page) is_heavier_enough that_it
may_be easier to_just build a_js-first site to start_with.

~~~
smadge
It all depends_on_the use case. I'm just trying to refute the parent comment.
In some situations, e.g._when_you are_starting_with_server side logic and
rendering, progressive_enhancement is actually less effort._You get_it for
free since all user agents support html._Some_applications might justifiably
start_out as single page applications. Other make more sense_using the
metaphor of hyperlinked resources.

~~~
sanderjd
Here is_my own personal_experience:_You're_fighting user expectations by_doing
things this way. Your users almost_unanimously don't care how you architect
your_application, but they are used to using_Facebook, Gmail, Dropbox, AirBnB,
etc. etc. and_they will eventually expect and_ask you_for the same sort of
experience,_at which point_you will_put more time_into tacking on dynamic
features to a_static application than_you would have spent designing a_dynamic
application_to begin with._Then_you'll_probably end_up re-writing the_complex
portions_(and eventually_all_portions, because hybrids suck to maintain)_in_a
front-end framework and pulling out the back-end_logic into a convenient_API,
and_coming to the conclusion_that you would have started_that way if you knew
you were_going to_end that_way. Then you'll start looking at new applications
through that lens of_whether your users will ever want_that sort of dynamism,
and_you'll start_concluding_pretty much every_time_(because nobody__ever_ asks
you to build a blog or_publication site)_that your users will want that_sort
of thing, so you're_better_off going dynamic up front. Now_you just have the
(smaller, IMO) problem_of what to do about_the_users_who don't want the
dynamic stuff,_and if you're successful enough that_you can afford_to invest
in it, you can put the_time_into progressive enhancement, which (in my
opinion!)_is_easier than retro-fitting rich front-ends onto_static_apps.

This_may all be wrong at_each step, but hopefully it illuminates_a bit how a
lot of us (otherwise sensible developers)_ended up thinking_it makes more
sense to start_most_things_as rich