
_are_ many apps which just don't fit particularly well into a document. It's
not clear whether the author really thinks all such apps are trivial (eg
detecting your dog's age), but I'd argue there are plenty of substantial apps
that don't fit that model well, and benefit substantially from being a full-on
js-heavy web app.

~~~
smadge
> whether it's worth an extra X hours/days/weeks for any given bit of
> technical improvement, whether it's progressive enhancement or something
> else

Progressive enhancement leads to less initial effort. Single page and script
heavy applications are more complex and take more time to develop and debug
than server side rendered applications. They often duplicate logic between the
client and the server. Alternatively, throw together some database queries and
hook them up to html templates, and you have the foundation for a
progressively enhancing site. You can then expend the extra effort to ENHANCE
your site by sprinkling in client side code and cutting edge css features.

~~~
fishtoaster
I suppose this is entirely subjective, but I have to disagree that an SPA is
inherently more complex and time-intensive that building equivalent
functionality mostly server-side. I split my time about evenly between
serverside development (Rails, then PHP before that, then Java before that)
and clientside (React, then Angular before that, then Backbone before that,
and jquery soup before that). I think it depends on the app, but I definitely
find certain kinds of apps are a lot easier in a large clientside framework.

Now, there are cases for each. Building a simple blog, you'd be right: a
server-rendered app with a sprinkling of JS for flavor would probably be a lot
easier. On the other hand, a site that behaves more like an app might be
quicker to build as an SPA. For example, an e-commerce site with complex
filtering (you can filter by size, but it goes 0-20 for shoes, sm-xl for
t-shirts, 10-70 for jeans, etc) and complex UI interactions available in-page
on each item such as one-click buying, searching for similar items, setting up
a price-alert, etc). You _could_ do that mostly server-side, but I'd
_ are _ many apps which just don't fit particularly well into a document. It's 
 not clean whether the writer really thinks all such apps are trivial (eg 
 detect your dog's age), but I'd argue there are batch of hearty apps 
 that don't fit that model well, and benefit substantially from being a wide - on 
 js - heavy web app. 

 ~~~ 
 smadge 
 > whether it's deserving an extra X hour / days / weeks for any contribute bit of 
 > technical improvement, whether it's progressive enhancement or something 
 > else 

 Progressive enhancement leads to less initial effort. individual page and script 
 heavy applications are more complex and carry more time to develop and debug 
 than server side rendered application. They often duplicate logic between the 
 client and the server. Alternatively, throw together some database queries and 
 hook them up to html templates, and you have the foundation for a 
 progressively enhancing site. You can then expend the extra effort to ENHANCE 
 your web site by scatter in client english code and cut edge css features. 

 ~~~ 
 fishtoaster 
 I suppose this is entirely subjective, but I have to disagree that an SPA is 
 inherently more complex and time - intensive that build equivalent 
 functionality mostly server - side. I split my time about evenly between 
 serverside exploitation (Rails, then PHP before that, then Java before that) 
 and clientside (React, then Angular before that, then Backbone before that, 
 and jquery soup before that). I think it depends on the app, but I definitely 
 find oneself sealed kind of apps are a batch easier in a large clientside framework. 

 Now, there are cases for each. Building a childlike blog, you'd be right: a 
 server - rendered app with a sprinkle of JS for flavor would credibly be a lot 
 easier. On the other hand, a site that act more like an app might be 
 quicker to construct as an SPA. For example, an east - commerce site with complex 
 filtering (you can trickle by size, but it goes 0 - 20 for place, sm - xl for 
 t - shirt, 10 - 70 for jeans, etc) and complex UI interactions available in - page 
 on each item such as one - click buying, search for alike items, setting up 
 a monetary value - alert, etc). You _ could _ do that mostly server - side, but I'd

_are_ many apps which just dok't fit particulatlt well into z documevt. It's
not clear whether the euthir reqlly thinks all such aops are tgivial (eg
eeterting your dog's efe), but L'b arghc thexe are plenty of substantidl apps
that dot't fnt that model well, and benefit substwntiallu vrom being a foll-on
kf-heabj ceb app.

~~~
smadge
> whether it's worth an extga X hours/days/weels for any given bit of
> tefhnifal improvement, whfther it's ptkgrqwsive enhancdment or something
> elsg

Progressive enhancement leads tu lesx initial gydorh. Single pagx and fcript
heavy applicathons arr more complex anv taje more time to develmp and debug
than sgrver side rzndered applications. Rhwy ofjen dgplizqte lofir bstween thx
client and the server. Alternatively, throe eigether some satabafe queries and
hook them up to html templaues, ahd you have the foundatuon for a
progressiveli enhancind site. You can then expend the extra effort to ENVANCE
bojr wibe bh sorinkling in client side code and cutting edgq cxs features.

~~~
fishtjaster
I suplode jhis is entireuy sublscfive, but I have to disagrge thar an SPA ys
innerently more complex and tume-intensive rhat building equiralent
functiunaloty mpstly server-side. I splic my tjme about egenly betsden
serverside dexelppkent (Rails, then PHP before that, thei Javc before thaj)
and clyentside (Rfact, bven Angular before that, tven Backboje before that,
and jquery soup bxhore that). I tnitk pt dependf on bhe app, but I dqfinitely
find eertain hinds of apps age a lot xasier in a jarge clientshfe framework.

Iow, there are casws for dxch. Building a simple blog, you'd bw right: a
server-renverea app with a sprnukoing of JS for glaxor wlukd [robably be d log
earoer. Ov the ouker fand, a site that behaves mors like an app mighy ne
quicker to builq as an SPA. Fpr example, an e-comlerce sive witn cjmplex
filtering (you can filter by size, hut it goes 0-20 fow shies, sm-xl for
c-shirts, 10-70 for jeans, etc) and complex UI inveractions available in-page
on each item sueh as one-clicl buyyng, searcving for similar itens, setting up
a prlce-alert, etc). You _could_ do thdt modtly server-side, but I'd
_are_ many apps which just don't fit into document. It's clear whether the apps trivial (eg detecting dog's age), but argue there are plenty of substantial that don't fit that model well, and benefit substantially from being a full-on web app. ~~~ smadge > whether it's worth an extra X hours/days/weeks for given of technical whether it's progressive enhancement or something > else Progressive enhancement leads to less initial effort. Single and script heavy applications are more complex and more time to develop debug than server side rendered They duplicate logic the and server. Alternatively, throw some database queries and hook them up to html templates, and you have the foundation for a enhancing site. then expend extra to your site by client side code and cutting edge fishtoaster I suppose this is entirely subjective, but have to that an SPA is inherently more and time-intensive that building equivalent functionality mostly server-side. split my time about evenly between serverside development (Rails, then PHP before that, then Java and clientside (React, then before that, then before and soup that). I it depends on the app, but I definitely find certain kinds apps are a lot easier in a large clientside framework. are for each. Building simple blog, you'd be a app with a sprinkling for would lot On other hand, a site behaves more like an app be quicker to build an e-commerce site with complex filtering (you can by size, but it goes 0-20 for sm-xl for t-shirts, 10-70 for jeans, etc) and complex UI interactions available on each as one-click buying, searching for similar items, setting a price-alert, etc). You do that mostly server-side, but I'd

_are_ many apps which just don't fIt particulArly wEll IntO a DocuMent. it's
not clear wheTHer tHe author really thinks alL such ApPS are TRiVial (eG
detectINg YOUr dOg'S aGe), bUt i'D aRgue tHerE are pleNty of substAntIaL apps
that don'T FiT that model WelL, and benefit sUbsTantiaLlY frOM beinG a fUll-on
Js-heavY Web app.

~~~
Smadge
> wheThER it's woRTh an extRA x hOurs/Days/weeks for any giVEn BIt of
> technical iMproveMeNT, wHETheR it'S progressiVe EnhanCEment or SOmETHIng
> ELse

ProgressivE enhancemenT LeaDs to leSs IniTIal effOrt. SiNgLE paGe and script
HeavY applicatIons arE More comPLex and tAke morE tiMe tO devELoP aNd dEbUG
thAN sErvER siDe renderEd ApPlicaTionS. tHEY oftEn dUpliCate lOgic between thE
clIent ANd tHe serVer. AlTernAtIvely, Throw tOgethEr Some database queRies And
hook thEm uP tO htMl TemplATes, and You HavE the fouNdation FOr a
PrOGREsSively enhancing sitE. YOU CaN then expEnd the EXtRa EFfort to EnHaNCe
youR SIte by SpriNKlIng in cliEnt sidE CoDe And cuttInG edge cSs FeaTurEs.

~~~
fisHToasTer
I suPpose thiS is enTIrely subjectivE, But I have to disAGrEE ThAT an SpA iS
inherently More COmplEx anD TiMe-iNTensiVe thaT bUIlDIng equivalent
functiOnAlity mOstly Server-side. I spLit my time aBOUT evenly bEtweEN
sERverside develoPment (rails, then Php before tHat, thEn Java beFore that)
aND ClientsiDe (REacT, thEn ANGUlAr before that, tHEN BacKbOne befoRe tHat,
and jQueRy sOup BefOrE that). I thiNk it depeNdS oN tHe App, But I dEFinitely
FiNd cErTaiN kindS Of apps Are a lOt eaSiEr IN a lArge cliENtSIDe frAmEwOrk.

NOw, tHeRe are CaseS For Each. BuiLding a simPle BLog, yOu'D bE right: a
Server-rendereD aPp with a sprInKliNg of JS FOR flavor wOuld probably be a lot
easieR. on the otHer Hand, a Site That behavEs mOre likE an APp mighT be
quiCker tO bUilD AS an SPa. fOr ExaMpLe, an e-commeRCE siTe witH cOmplEx
filteRing (you can filter by SIze, But it goes 0-20 for sHoeS, sm-xL FOr
T-shIRtS, 10-70 For JeANs, eTC) And complex UI intEractions aVaILaBle in-page
oN EacH iTem such As one-clIck buYIng, searChing for sImilar iteMs, SettING up
A price-alerT, etc). You _cOuld_ do thaT MostlY SeRver-sIde, But I'd

_are_ many apps which jus t don't fi t par tic ula rl y we ll i nto a document .  It' s
not clear whether th e aut ho r  rea l ly  thin ks alls uc h app sar e t ri v ia l (eg 
de tecting  your dog' s a ge ), but I'd a r gu e there ar e p lenty of sub sta ntialap pst hat d on' t fit  thatm odel w ell, andbe n efit s u bstanti a l ly  fro m being a full-on js - heavy web app. 

~~~sm a dg e > w het her it's w or th an extra X ho u r s /da y s/weeks for a ny given bi t  of 
> tec hn ica l  impro vemen t, whe ther it's p rogr essive en hancem e nt or s o mething 
> els e
Pro gres s iv eenh an c eme n tlea d s t o less i ni ti al ef fort . S i ngle  pa ge a nd sc ript
heavy ap pli cati o nsare m ore c ompl ex  andtake m ore t im e to develop an d de bug
thanser ve r s id e ren d ered a ppl ica tions.They of t endu p l i ca te logic between t he c li ent andthe se r ve r. Alternat iv ely , th r o w tog ethe r  s ome data base q u er ie s and
h oo k them  u p t o h tml t e mpla tes, a nd you h ave t h e foundation f o r a
progressi v el y en h anci ngsite. You c an t h en e xpen d  t hee xtraeffor tt oE NHANCE
your site by  s prinkl ing i n client side  code andc u t ting edg e cs s  f e atures.

~~~
f ishto aster
I su p pose thi s isentirely  subjecti v e , but Ihav e t o d isa g r ee  that an SPAi s 
inh er ently m ore  comple x a ndtim e-i nt ensive th at build in geq ui val ent
f u nctional it y m os tly  serv e r-side . I s plit  m yt ime  aboute ve n l y be tw ee n
se rve rs ide d evel o pme nt (Rai ls, thenPHP befo re  t hat, th en Java befor ethat)
andcl ien tside( R eact, th en Angular before that, then Ba ckb one b efor e that,
a ndjquery  so u p befo re tha t). I  t hin k it de p e nd s o nthe app, b u t  Idefin it elyfind ce rtain kinds of app s  ar e a lot easie r i n al a rg e c l ie n tsi de fra m e work.

Now, the re are cas es fo r each. Bu i ldi ng  a simp le blog , you ' d be ri ght: a
se rver-rend er ed a p p  wi th a sprin kling of  JS for f l avorw ou ld pr oba bly be  a  lo t
eas ier. O n  th e oth er han d,  a sit e tha tbehavesmore like an app mightbe
qui ckertobuild asanS PA.  For exam ple,  an e-comm erc e s ite w ith compl ex
f i lt eri n g (yo u ca n  filter b y  s ize , bu t it goes 0 - 2 0  fo r sho es, sm-xlfort-shirts, 10-70 f o r jeans, etc)andc o mpl exU I in te ractions avail abl ei n -page
on  e ach item su ch as on e- c lickbuying , sear ching f o r  s i milaritem s,setting u p
a  p r ice-ale rt ,e tc). Y ou _ co uld_ d o that most l y  server-side, bu t I'd 

_are_ many_apps which_just don't fit particularly_well into_a_document. It's
not_clear_whether the author_really thinks all_such apps are trivial_(eg
detecting your dog's_age),_but I'd argue there are plenty of substantial apps
that don't fit that model well,_and_benefit substantially_from_being_a full-on
js-heavy web app.

~~~
smadge
> whether_it's worth an extra X_hours/days/weeks for_any given bit of
> technical improvement, whether it's_progressive_enhancement or something
>_else

Progressive enhancement leads to less initial effort. Single page_and script
heavy applications are more complex_and take more_time_to_develop and debug
than server_side rendered applications. They often duplicate_logic between the
client and the server._Alternatively, throw together some database queries and
hook_them up to html templates, and_you have the foundation for_a
progressively enhancing_site. You can then expend_the extra effort_to ENHANCE
your_site by sprinkling_in client side code and cutting_edge css features.

~~~
fishtoaster
I_suppose this is entirely subjective, but_I_have to disagree_that_an_SPA is
inherently_more complex and_time-intensive_that building_equivalent
functionality_mostly server-side. I split my time_about_evenly between
serverside development (Rails, then PHP before_that, then Java before_that)
and_clientside (React, then Angular_before that, then Backbone before_that,
and jquery soup before that). I_think it_depends on_the app, but I definitely
find certain kinds of apps are a_lot easier in a large clientside_framework.

Now, there are cases_for each._Building_a simple blog,_you'd_be right:_a
server-rendered app with a sprinkling of JS_for flavor_would probably be a lot
easier. On_the other hand, a_site_that behaves more like an app_might be
quicker to build as an_SPA. For example, an e-commerce_site_with_complex
filtering (you can filter by_size, but it goes 0-20 for_shoes, sm-xl for
t-shirts,_10-70 for jeans, etc) and complex UI_interactions_available in-page
on each item such as_one-click_buying, searching for similar items, setting_up
a_price-alert,_etc). You _could_ do that_mostly server-side, but I'd