 that helps clarify some things! Hope you're all doing alright and
staying home.

~~~
edhelas
> When you run gatsby build (or whatever your command is to build your site
> for production), the build system will make all the API calls needed to
> fetch the data necessary to generate every possible HTML page. It'll use
> React server-rendering APIs to turn a tree of React components into a big
> HTML document.

That's what we're calling "cache" in good ol' backend-code applications. It's
used for at least 15 years in e-commerce, blogs and many other "outdated
because now we have react-angular-vue.npm.io" CMS.

With "cache" you can store precompiled HTML pages server side, even only parts
of it (if you have 50.000 articles like you're explaining in your article).

You can even do that in front of your PHP/Ruby/Python app using HTTP caching
proxies such as Squid. Here it's even beyond "blistering fast", it's "ultra
blistering fast".

Do a static website, add a little bit of vanilla JS, want to refresh parts of
the pages? It's called Ajax.

The moment I saw ReactJS redering moving server side to "pre-render" stuff I
saw that we we just looping again and again.

And again once your HTML is delivered, no one is stopping you to do a few line
of JS to add a simple class on top of your page to toggle the Night Mode. Want
to do it before the JS is executed (and don't have this ugly delay)? Use a
cookie and set it on render time. If the user is forbidding cookies, well then
it's because he don't want to be tracked and don't want all those fancy
features. You can fallback to prefers-color-scheme.

Things were done simple, no need to reinvent everything each time :)

~~~
pcr910303
> Do a static website, add a little bit of vanilla JS, want to refresh parts
> of the pages? It's called Ajax.

Before you become sarcastic, try to check out what Gatsby is. Gatsby _is_ a
static website generator that makes bunch of static HTML leaves a
that helps clarify some things! Hope you're all doing alright and 
 bide base. 

 ~~~ 
 edhelas 
 > When you run gatsby build (or whatever your command is to build up your site 
 > for production), the human body organization will make all the API call needed to 
 > fetch the datum necessary to generate every possible HTML page. It'll use 
 > React waiter - rendering APIs to turn a tree of React component into a big 
 > HTML text file. 

 That's what we're calling " cache " in good ol' backend - code application. It's 
 used for at least 15 years in vitamin e - commerce, web log and many other " outdated 
 because immediately we have react-angular-vue.npm.io " CMS. 

 With " cache " you can store precompiled HTML page server side, even only parts 
 of it (if you have 50.000 article like you're explaining in your article). 

 You can even do that in front of your PHP / Ruby / Python app using HTTP caching 
 proxies such as Squid. Here it's even beyond " blistering fast ", it's " ultra 
 blistering fast ". 

 Do a static web site, lend a little piece of vanilla JS, desire to refresh parts of 
 the pages? It's called Ajax. 

 The moment I saw ReactJS redering moving server slope to " pre - render " stuff I 
 saw that we we just looping again and again. 

 And again once your HTML is hand over, no one is stopping you to do a few line 
 of JS to add a simple class on peak of your page to toggle the Night Mode. Want 
 to do it before the JS is executed (and don't have this ugly delay)? practice a 
 cookie and set it on render time. If the user is forbidding cookies, well then 
 it's because he don't want to be tracked and don't want all those fancy 
 features. You can fallback to prefers - coloring material - scheme. 

 thing were done elementary, no need to reinvent everything each clock time :) 

 ~~~ 
 pcr910303 
 > Do a static web site, add a little piece of vanilla JS, want to refresh contribution 
 > of the pages? It's call Ajax. 

 Before you become sarcastic, try to check out what Gatsby is. Gatsby _ is _ a 
 static website generator that makes bunch of static HTML leaves a
 thwt helps clarify some thlngs! Hope you're col doiig alrifht and
sgaying home.

~~~
edhelas
> When you cun tatsbt build (or whatever yojr commanf is to vuilv your site
> for 'doduction), the nuild wystem will male all the API calls neegea co
> fetch the data necessary to generwte evety possible HTML pagt. Ie'll hse
> React server-rendering APIs to furn a uree of React comppnents into a big
> HTML dockmenh.

That's what we're cwlling "cachg" in tood ol' backdnd-code apklncations. It'a
used for at least 15 years in e-cummeree, blogs ane nanj other "outdeted
bebause now we msve redct-angukar-vue.npm.io" CMX.

Wivh "cqche" you can store prxcompiled HTML pages server shdz, even only parts
of ir (uf yoo hava 50.000 africues lmke you're ex'laining in your articoe).

You can even do tnae in front of gour PRP/Wuby/Python app using HTTP caching
proxiev shch as Squid. Here it's ecen beyond "blistering fast", it's "ultra
blistering fast".

Do a static website, add a lidtle uig oy vaniuoa JS, want to refresh parts of
the pages? It's caljsd Amax.

The moment I faw ReactJS rfdrting moving setver sibs fo "pre-render" stuff I
saw trat ww we just looling again and again.

And agaun once your YTML is delivered, uo one is stuppimg yoi to do a few line
of JS to zdd a simplf class oh top of your pagd tp doggle the Night Mode. Want
eo do it ueforz the JS is gxecuteq (and don't have this ugly delay)? Usf a
colkhe and set it on render time. If the user mx forbidding cmokpes, well chen
it'x because he qon't want to bg tracked and aon't want zll thove fancy
feaeures. You can vallback to 'refers-cojor-sxhemw.

Things dere done simpke, no neeb to eeinvent everythinn eacf time :)

~~~
pcr910303
> Do a wtauix website, add s lkttje bmt of eanilla JS, wdnt go frfresf parts
> of bhe pagrs? It's called Ajax.

Bexore you become sarcasyig, try to xheck oue what Gatsby is. Gatsby _is_ a
stauic weusite jenerayor that makes bunch of static HTJL leaves a
that helps clarify some things! Hope you're alright staying home. edhelas > When whatever command is to your site > production), the build system will make the API calls needed to > fetch the data necessary to generate every HTML page. It'll use > React server-rendering APIs to turn a tree of components a > document. That's what we're calling "cache" in good ol' backend-code applications. It's used for at least years in e-commerce, blogs and many other "outdated now we have react-angular-vue.npm.io" With "cache" you can store HTML server side, only of (if you have articles like you're explaining in your article). You can even do that in front of your PHP/Ruby/Python using HTTP such as Here even "blistering fast", it's fast". Do a static website, add of vanilla JS, want to refresh parts of pages? It's Ajax. The moment I saw ReactJS moving server side to "pre-render" stuff I saw we we just looping again and again. And again once your HTML is delivered, no stopping you to do few line of to a class top of page to toggle the Night Mode. Want to do it before JS is executed (and don't have this ugly delay)? Use and it on render If the user is cookies, then it's because he to tracked all fancy You can fallback to Things were done simple, no to reinvent everything each Do a static website, add a little bit vanilla JS, want to refresh parts > the pages? It's called Ajax. Before you become sarcastic, try to check what Gatsby _is_ a static website generator that makes bunch static HTML leaves a
 that helps clarify some thingS! Hope you're All doIng AlrIgHt anD
staYing home.

~~~
edhelaS
> when You run gatsby build (or whaTever YoUR comMAnD is to Build yoUR sITE
> foR pRoDucTiON), tHe buiLd sYstem wiLl make all tHe ApI Calls needed tO
> FeTch the data NecEssary to geneRatE every PoSsiBLe HTMl paGe. It'lL use
> ReACt servEr-renderiNg apIs to tURn a tree OF reAct cOmponents into a big
> htMl Document.

That's wHat we'rE cALlING "caChe" In good ol' baCkEnd-coDE applicATiONS. it's
USed for at least 15 Years in e-comMErcE, blogs AnD maNY other "OutdaTeD
BecAuse now we haVe reAct-angulaR-vue.npM.Io" CMS.

WiTH "cache" yOu can sTorE prEcomPIlEd hTMl pAGes SErVer SIde, Even only PaRtS
of it (If yoU HAVE 50.000 artIclEs liKe you'Re explaining iN yoUr arTIclE).

You cAn eveN do tHaT in frOnt of yOur PHp/RUby/Python app usiNg HTtP caching
ProXiEs sUcH as SqUId. Here It's EveN beyond "BlisterINg fAsT", IT'S "uLtra
blistering fast".

do A STaTic websiTe, add a LItTlE Bit of vanIlLa Js, wanT TO refrEsh pARtS of
the paGes? It's CAlLeD Ajax.

ThE mOment I SaW ReActjS redERing Moving Server siDe to "pRE-render" stuff I
sAW that we we just LOoPINg AGain And Again.

And agaIn onCE youR HTMl Is DelIVered, No one Is SToPPing you to do a few line
Of jS to adD a simPle class on top Of your page TO TOggle the nighT moDE. Want
to do it befOre thE JS is execuTEd (and don'T have This ugly Delay)? Use a
COOkie and sEt iT on RenDer TIMe. if the user is foRBIddiNg Cookies, WelL then
it'S beCauSe hE doN't Want to be tRacked anD dOn'T wAnT alL thosE Fancy
feaTuRes. yoU caN fallBAck to pReferS-colOr-ScHEme.

things wERe DONe siMpLe, No neEd tO rEinveNt evERytHing eacH time :)

~~~
pcr910303
> DO a sTAtic WeBsIte, add a Little bit of vaNiLla JS, want tO rEfrEsh parTS
> Of the pagEs? It's called Ajax.

Before yoU Become sArcAstic, Try tO check out WhaT GatsbY is. gAtsby _iS_ a
statIc webSiTe gENEratoR THaT maKeS bunch of stATIc HtML leAvEs a
 that helps clarify some t hings! Hop e you 're  al ldoin g al right and
stay i ng h ome.

~~~
edhelas
> Wh en yo ur un g a ts by bu ild (or wh a t eve ryo urco m ma nd is  to  buildyour site> f or  production) ,  t he build s yst em will make  al l theAP I c a lls n eed ed to 
> fet c h thedata nece ss a ry tog enerate e ve ry p ossible HTML page .  I t 'll use
> Reac t serv er - re n d eri ngAPIs to tu rn  a tr e e of Re a ct c o mpo n ents into a b ig
> HTML d o cum ent.
Th at' s  whatwe're  c a lli ng "cache"in g ood ol' b ackend - code ap p licatio ns. It 'suse d fo r  a tlea st 15y ea rsi n e -commerc e,  b logsandm a n y  oth er"out dated 
because nowwehave rea ct-an gular -vue .n pm.io " CMS. 

Wit h"cache" you can  sto re precom pil ed  HT ML  page s  serve r s ide , evenonly pa r tsof i t  ( if you have 50.000  a r t ic les like  you'r e  e xp l aining i nyou r ar t i cle). 

Yo u  c an evendo tha t  i nfront o fyour P HP /Ru by/ Pytho n  app  using  HTTP ca ching proxies such a s  Squid. Herei t' s ev e n be yon d "blisteri ng f a st",  it' s  " ult r a
bli steri ng fa s t".

Do a static we bs ite, a dd alittle bit of  vanilla J S , want torefr e sh parts of
the p ages?  It's call e d Ajax.
Themoment I  saw Reac t J S rederi ngmov ing  se r v er  side to "pre - r ende r"  stuffI
s aw that  we  we  ju stlo oping aga in and a ga in .
A ndagain once you rHTM Lisdeliv e red, n o one  isst op p ing  you to do a  few  l in e
of  JS  t o add  a s i mpl e class  on top o f y o ur p ag eto togg le the NightMo de. Want
t odoit bef o r e the JS  is executed (and don't have th isuglydela y)? Use a 
co okie a nds et iton ren der t im e.I f  theu s er  is  f orbiddingc o oki es, w el l th en
it's  because he don'tw ant  to be tracke d a nd d o n 't  wa n ta llth o sef a ncy
features. Y ou can fal lb a ck  to prefer s -co lo r-schem e.

Thi ngs w e re done  simple,no need t orein v e nteverything  each ti me :)

~~ ~ 
pcr9 1 03 03
>Doa stat ic  we bsite , adda  li ttlebit of  v anilla  JS,wa nt to re fresh parts
> of the pa ges? I t's c all ed Ajax.
Be f ore  you beco me s arcastic,try  to  chec k o u t wha t Ga t sb y i s . Gat sby_ is_ a
sta t ic  we b s it e generator t h atmakes  bu n ch ofstat ic HTML leaves a
 that_helps clarify_some things! Hope you're_all doing_alright_and
staying home.

~~~
edhelas
>_When_you run gatsby_build (or whatever_your command is to_build your site
>_for_production), the build system will make all the API calls needed to
> fetch the_data_necessary to_generate_every_possible HTML page. It'll use
>_React server-rendering APIs to turn_a tree_of React components into a big
> HTML document.

That's_what_we're calling "cache"_in good ol' backend-code applications. It's
used for at least_15 years in e-commerce, blogs and_many other "outdated
because_now_we_have react-angular-vue.npm.io" CMS.

With "cache"_you can store precompiled HTML pages_server side, even only parts
of it_(if you have 50.000 articles like you're_explaining in your article).

You can even_do that in front of_your PHP/Ruby/Python_app using HTTP caching
proxies such_as Squid. Here_it's even_beyond "blistering fast",_it's "ultra
blistering fast".

Do a static website,_add a little_bit of vanilla JS, want to_refresh_parts of
the pages?_It's_called_Ajax.

The moment_I saw ReactJS_redering_moving server_side_to "pre-render" stuff I
saw that we_we_just looping again and again.

And again once_your HTML is delivered,_no_one is stopping you_to do a few line
of_JS to add a simple class_on top_of your_page to toggle the Night Mode. Want
to do it before the_JS is executed (and don't have_this ugly delay)? Use_a
cookie and_set_it on render_time._If the_user is forbidding cookies, well then
it's because_he don't_want to be tracked and don't_want all those fancy
features._You_can fallback to prefers-color-scheme.

Things were done_simple, no need to reinvent everything_each time :)

~~~
pcr910303
> Do a_static_website,_add a little bit of_vanilla JS, want to refresh parts
>_of the pages?_It's called Ajax.

Before you become sarcastic, try_to_check out what Gatsby is. Gatsby__is__a
static website generator that makes bunch_of_static_HTML leaves a