Třicet let. Tak dlouho už web existuje v podobě, kterou bychom dnes alespoň zhruba poznali — od prvních statických dokumentů přes éru aplikací běžících v prohlížeči až po kód, který se spouští na stovkách míst po celém světě jen pár milisekund od uživatele. Tenhle příběh ale není jen suchým výčtem technologií a verzí. Je to příběh jednoho kyvadla, které se celé tři dekády houpe mezi serverem a klientem — a které právě teď nachází nový bod rovnováhy někde uprostřed, na okraji sítě. Pojďme si těch třicet let projít tak, jak se odehrávaly: jako sled problémů a chytrých odpovědí, z nichž každá založila něco, co používáme dodnes.

Než začneme: kyvadlo, které se nikdy nezastaví

Pokud byste měli historii webu shrnout do jedné věty, mohla by znít takhle: je to nepřetržité přetahování o to, kde se má provádět výpočet. Na začátku všechno počítal server a prohlížeč jen vykresloval hotové stránky. Pak se těžiště přesunulo do prohlížeče, který zmohutněl natolik, že se z něj stala plnohodnotná aplikační platforma. Poté se kyvadlo zhouplo zpátky na server, protože čisté klientské aplikace měly své bolesti. A dnes? Dnes se hranice mezi serverem a klientem rozpouští a výpočet se rozprostírá do distribuovaného kontinua, jehož novým, klíčovým bodem je edge — výpočetní uzly fyzicky blízko uživateli.

Když budete tenhle motiv sledovat, dají vám smysl i jinak nesouvisející technologie. CGI, PHP, AJAX, jQuery, REST, Node.js, React, Next.js, serverless, WebAssembly i Cloudflare Workers jsou v zásadě odpovědí na pořád stejnou otázku: Kde a kdy se má kód spustit, aby byl výsledek rychlý, levný a snadno udržovatelný? A souběžně s tímhle hlavním motivem poběží několik vedlejších linek — vývoj stylů, prohlížečů, datových vrstev a bezpečnosti — bez kterých by celý příběh nedával smysl.

1991–1995: Web jako knihovna dokumentů

Na úplném počátku nebyl web platformou. Byl to systém pro sdílení dokumentů. Tim Berners-Lee v CERNu navrhl v roce 1989 hypertextový systém, který by fyzikům umožnil propojovat dokumenty napříč počítači, a v roce 1991 spustil první webovou stránku. Tři pilíře, které tehdy položil — HTML jako značkovací jazyk, HTTP jako protokol a URL jako adresování — fungují dodnes. To je samo o sobě pozoruhodné: drtivá většina technologií z roku 1991 je dávno mrtvá, ale tahle trojice stále drží celý web pohromadě.

První weby byly statické v nejdoslovnějším smyslu. Soubor .html ležel na disku serveru a ten ho na vyžádání poslal beze změny prohlížeči. Žádná interaktivita, žádný stav, žádné přihlašování. Příchod grafického prohlížeče Mosaic v roce 1993 a po něm Netscape Navigatoru v roce 1994 přinesl obrázky přímo do textu a web se z akademické kuriozity začal měnit v médium pro veřejnost.

Byla to syrová, ale svým způsobem kouzelná doba. Stránky se sázely pomocí tabulek vnořených do tabulek, k formátování sloužil neblaze proslulý tag <font>, mezery se vynucovaly průhledným obrázkem spacer.gif o velikosti jednoho pixelu a o rozvržení se staraly rámy (frames). Weby zdobily animované cedule „ve výstavbě“, počítadla návštěv a kroužky vzájemně propojených stránek (webringy). Přes vytáčené modemy to bylo pomalé a obrázek se načítal řádek po řádku odshora dolů — ale poprvé to bylo dostupné komukoli.

Server se probouzí: CGI, PHP a jazyk napsaný za deset dní

Statické dokumenty rychle přestaly stačit. Lidé chtěli návštěvní knihy, počítadla přístupů, vyhledávání a zpracování formulářů — zkrátka obsah, který se mění. Odpovědí bylo CGI (Common Gateway Interface): rozhraní, přes které mohl webový server pro každý požadavek spustit externí program, nejčastěji skript v Perlu, a jeho výstup poslat zpět prohlížeči. Web se poprvé naučil reagovat. Cena za to byla vysoká — pro každý požadavek se spouštěl celý nový proces, což se při rostoucí návštěvnosti měnilo v noční můru.

Rok 1995 byl pro server přelomový. Rasmus Lerdorf vydal sadu nástrojů, kterou nazval PHP (původně „Personal Home Page Tools“), a dramaticky tím snížil bariéru pro tvorbu dynamického webu. PHP se dalo psát rovnou doprostřed HTML, běželo dobře a šířilo se rychlostí lavinového sesuvu. Vznikl pozdější stack LAMP (Linux, Apache, MySQL, PHP) — kombinace, na které stála velká část internetu příští dekády. Typický kód té doby vypadal nějak takhle:

<?php
echo "<h1>Vítejte na mém webu!</h1>";
echo "<p>Stránka vygenerována: " . date("d.m.Y H:i") . "</p>";

$pocet = (int) file_get_contents("counter.txt");
file_put_contents("counter.txt", $pocet + 1);
echo "<p>Jste " . ($pocet + 1) . ". návštěvník.</p>";
?>Code language: HTML, XML (xml)

Zatímco server získával svaly, na straně klienta se odehrávalo něco, co dodnes určuje podobu webu. Netscape potřeboval do prohlížeče skriptovací jazyk, který by uměl validovat formuláře a oživit stránku, aniž by musel kontaktovat server. Úkol dostal Brendan Eich a podle legendy na to měl zhruba deset dní. Výsledek nesl pracovní jména Mocha a LiveScript, než dostal marketingově výhodné, byť matoucí jméno JavaScript (s Javou má pramálo společného). Spěch, ve kterém vznikl, mu zůstal v genech na desítky let — i ty nejpodivnější vlastnosti jazyka jsou daní za onen šibeniční termín.

Tahle éra je také érou válek prohlížečů. Netscape a Microsoft Internet Explorer mezi sebou soupeřily tím, kdo přidá víc proprietárních vlastností, a každý si standardy ohýbal po svém. Pro vývojáře to znamenalo psát kód dvakrát a testovat trojnásobně. Tahle fragmentace měla obrovský dopad: na dlouhá léta zabrzdila inovaci na klientu a vytvořila prostředí, ve kterém se každá nová technika musela rodit přes bolestivé „a co když to uživatel otevře v IE 6“.

Web 2.0: když se ze stránek staly aplikace

Na přelomu tisíciletí se začalo dít cosi zásadního. Microsoft kdysi pro Outlook Web Access přidal do Internet Exploreru nenápadnou komponentu XMLHttpRequest — schopnost prohlížeče poslat HTTP požadavek na pozadí a zpracovat odpověď bez nutnosti znovu načíst celou stránku. Nějakou dobu si jí skoro nikdo nevšímal. Pak přišel Google s Gmailem a Mapami Google a ukázal, co to dokáže: e-mail, který se nenačítal celý znovu jako klasická stránka, a mapa, kterou jste mohli plynule táhnout myší a ona donačítala dlaždice za běhu. Web najednou vypadal a choval se jako desktopová aplikace.

V roce 2005 dal Jesse James Garrett téhle technice jméno: AJAX (Asynchronous JavaScript and XML). Nešlo o žádnou novou technologii, ale o pojmenování přístupu, který spojil existující kousky do nového paradigmatu. Web 2.0 byl na světě — web čtení i zápisu, web aplikací, mashupů a uživatelského obsahu. Psát AJAX ručně ovšem byla otročina plná zpětných volání a kontroly stavů:

var xhr = new XMLHttpRequest();
xhr.open("GET", "/api/zpravy.php", true);
xhr.onreadystatechange = function () {
  if (xhr.readyState === 4 && xhr.status === 200) {
    document.getElementById("obsah").innerHTML = xhr.responseText;
  }
};
xhr.send();Code language: JavaScript (javascript)

A to jsme ještě nepřidali ošetření odlišného chování v jednotlivých prohlížečích. Právě tahle bolest vytvořila prostor pro nástroj, který na další roky ovládl frontend.

jQuery a éra, kdy DOM konečně poslouchal

V lednu 2006 vydal John Resig knihovnu jQuery a změnil tím každodenní život milionů vývojářů. Její slogan „write less, do more“ nebyl marketingovou nadsázkou. jQuery schovala rozdíly mezi prohlížeči pod jednotné API, zpřístupnila manipulaci s DOM přes elegantní selektory a z výše uvedené osmiřádkové ajaxové orgie udělala jednořádkový $.get(). Po dlouhá léta byla jQuery prakticky synonymem pro „JavaScript na webu“ a běžela — v jednu chvíli — na drtivé většině všech webů na světě.

Souběžně dospívalo i CSS. Hnutí za sémantické, beztabulkové rozvržení a projekty jako CSS Zen Garden ukázaly, že obsah a vzhled lze oddělit a že stejné HTML může vypadat stokrát jinak jen výměnou stylů. Web se profesionalizoval: vznikla role frontendisty, oddělená od backendu, a začalo se mluvit o přístupnosti, validním kódu a o tom, že stránka má dávat smysl i bez JavaScriptu.

Styly dospívají: od float hacků po Grid a Tailwind

Vývoj CSS si zaslouží vlastní kapitolu, protože byl dlouho příběhem důmyslného obcházení překážek. Jazyk neměl žádný skutečný systém rozvržení, a tak designéři zneužívali vlastnost float — určenou původně k obtékání obrázků textem — ke stavbě vícesloupcových layoutů a sváděli každodenní boj s clearfix triky a nejednoznačným modelem boxu. Aby si práci ulehčili, vznikly preprocesory Sass a LESS, které do CSS doplnily proměnné, vnořování a mixiny, a metodiky jako BEM zkrotily chaos v pojmenovávání tříd.

Skutečný zlom přišel se zavedením opravdových nástrojů pro rozvržení. Flexbox (kolem let 2012 až 2015) vyřešil jednorozměrné rozmístění prvků a CSS Grid (2017) přinesl konečně nativní dvourozměrnou mřížku — bez jediného hacku, deklarativně a responzivně. To, co dřív zabralo desítky řádků a hodiny ladění, se najednou vešlo do několika řádků:

.galerie {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
  gap: 1rem;
}Code language: CSS (css)

Poslední vlnu odstartoval v roce 2017 Tailwind CSS a s ním přístup „utility-first“ — styly se skládají z drobných utilitárních tříd zapsaných přímo do značek. Je to kontroverzní, dělí komunitu na dva tábory, ale popularitu má obrovskou. Ve světě Reactu zase ožil přístup CSS-in-JS s knihovnami jako styled-components. A samotné CSS mezitím tiše zmohutnělo: nativní proměnné, dotazy na kontejner (container queries) nebo selektor :has() z něj udělaly překvapivě mocný jazyk, který dnes zvládne věci, na jaké jsme si dřív museli volat JavaScript.

API jako lepidlo webu: od SOAP přes REST po GraphQL

Ve chvíli, kdy si prohlížeč přes AJAX začal sám stahovat data, muselo na druhé straně něco tato data poskytovat. Vznikl tak celý svět webových API a i ten má svou evoluci. První velké integrace stály na protokolu SOAP — formálním, ale těžkopádném přístupu, který data balil do rozměrných XML obálek a popisoval přes specifikaci WSDL. Bylo to robustní pro velké podnikové systémy, ale na lehký web příliš upovídané.

Mnohem víc webu slušel REST, který ve své disertaci popsal už v roce 2000 Roy Fielding. Postavil ho na jednoduchých principech: zdroje identifikované přes URL, standardní HTTP slovesa (GET, POST, PUT, DELETE) a bezstavovost. Když navíc upovídané XML postupně vystřídal lehký JSON, který byl JavaScriptu vlastní, stal se REST společným jazykem webu — páteří komunikace mezi SPA a serverem i základem backendů pro mobilní aplikace.

REST má ovšem své mouchy: často stáhnete víc dat, než potřebujete, nebo naopak musíte poslat několik požadavků, abyste posbírali vše potřebné. V roce 2015 na to Facebook odpověděl jazykem GraphQL — jedním rozhraním, kde si klient řekne přesně o ta pole, která chce, a dostane je v jediném dotazu:

query {
  uzivatel(id: 42) {
    jmeno
    objednavky(poslednich: 3) {
      cislo
      castka
    }
  }
}

Pro vysoce výkonnou komunikaci mezi službami navzájem se zase prosadilo binární gRPC. Žádný z těchto přístupů ostatní úplně nenahradil — REST, GraphQL i gRPC dnes žijí vedle sebe a každý se hodí na něco jiného.

2007 a mobil: HTML5, konec Flashe a responzivní design

V roce 2007 přišel iPhone a s ním plnohodnotný prohlížeč v kapse. To, co znělo jako příjemné rozšíření, byl ve skutečnosti tektonický posun: web se musel naučit fungovat na obrazovkách od pár centimetrů po velké monitory, s dotykovým ovládáním a na pomalejších mobilních sítích. Stará pravda „udělej to pro 1024 pixelů na šířku“ přestala platit ze dne na den.

Odpověď přišla v roce 2010 z pera Ethana Marcotta pod názvem responzivní webdesign — kombinace fluidních mřížek, flexibilních obrázků a media queries, díky níž se jeden web sám přizpůsoboval libovolné velikosti obrazovky. O rok později Twitter uvolnil Bootstrap, který responzivní mřížku zpřístupnil i vývojářům bez citu pro design, a responzivita se stala standardem. Brzy ji doplnil princip mobile first — navrhovat napřed pro malou obrazovku a teprve pak rozšiřovat.

Souběžně dozrával HTML5. Po letech, kdy se o budoucnosti značkovacího jazyka vedly spory mezi konsorciem W3C a pragmatickou skupinou WHATWG, přinesl HTML5 nativní přehrávání videa a zvuku přes tagy <video> a <audio>, kreslicí plátno <canvas>, sémantické elementy a celou řadu nových API. Tím odzvonilo technologii, která dvě dekády držela na webu animace, hry a video: Adobe Flash. Symbolickou ránu mu zasadil Steve Jobs otevřeným dopisem Thoughts on Flash v roce 2010, ve kterém vysvětlil, proč Flash nikdy nepoběží na iPhonu. Otevřené webové standardy vyhrály a Flash byl oficiálně pohřben na konci roku 2020.

Prohlížeče se sjednocují: konec válek a éra evergreenu

Vraťme se na chvíli k prohlížečům, protože jejich příběh dospěl ke šťastnému konci. Po temných letech vlády Internet Exploreru přišla druhá válka prohlížečů. Z popela Netscapu vzešel pod hlavičkou Mozilly v roce 2004 Firefox a poprvé dal IE skutečnou konkurenci. Pak v roce 2008 vstoupil do hry Google s prohlížečem Chrome — rychlým díky enginu V8, s minimalistickým rozhraním a důrazem na dodržování standardů — a počítadlo tržního podílu se začalo překlápět v jeho prospěch.

Následovala konsolidace vykreslovacích jader. Trident z Internet Exploreru postupně vymizel, Opera opustila vlastní engine Presto a dokonce i Microsoft postavil v roce 2020 nový prohlížeč Edge na základech Chromia. Dnes web pohánějí v zásadě tři jádra: Blink (Chrome, Edge, Opera, Brave), WebKit (Safari) a Gecko (Firefox), přičemž Blink jasně dominuje. Je to dvojsečné: na jednu stranu nebývalá konzistence, na druhou stranu oprávněné obavy z monokultury postavené kolem jednoho enginu.

Nejtišší, ale možná nejdůležitější revolucí byly evergreen prohlížeče, které se samy automaticky aktualizují. Noční můra typu „funguje to v IE 6, ale ne v IE 7“ z velké části skončila. Vývojáři se konečně mohli spolehnout, že nová vlastnost standardu se k uživatelům dostane během týdnů, ne let. Internet Explorer byl definitivně odeslán do důchodu v roce 2022 a s ním skončila jedna celá éra utrpení.

Node.js: JavaScript opouští prohlížeč

V roce 2009 udělal Ryan Dahl něco, co znělo skoro absurdně: vzal Googlem vyvinutý výkonný JavaScriptový engine V8 z prohlížeče Chrome a postavil kolem něj serverové běhové prostředí. Vzniklo Node.js a s ním možnost psát backend ve stejném jazyce jako frontend. Klíčem byl neblokující, událostmi řízený model, který se výborně hodil pro síťové aplikace obsluhující tisíce souběžných spojení.

Ještě důležitější než samotný runtime byl ekosystém, který kolem něj narostl. Balíčkovací nástroj npm, spuštěný v roce 2010, se stal největším registrem softwarových knihoven na světě a proměnil způsob, jakým se staví aplikace — z psaní kódu se z velké části stalo skládání hotových balíčků. JavaScript, dosud jazyk hraček v prohlížeči, se přes noc stal jazykem, ve kterém šlo napsat úplně všechno: server, nástroje pro sestavení, desktopové aplikace přes Electron i kód pro IoT.

Nástroje, které staví web: od Grunta po Vite

Jak frontend mohutněl, stal se z něj plnohodnotný software, který bylo potřeba sestavit. Najednou bylo nutné překládat moderní JavaScript do staršího, spojovat desítky souborů do jednoho, minifikovat výsledek a optimalizovat obrázky. Nejprve tyhle nudné práce automatizovaly úlohové běhouny Grunt (2012) a Gulp. Po nich převzal vládu Webpack — bundler, který rozuměl celému grafu závislostí a uměl dělit kód na menší části nebo za běhu vyměňovat moduly bez obnovení stránky.

Daň za tu sílu ovšem byla rychlost. U velkých projektů trvalo nastartování vývojového serveru i desítky sekund a každá změna v kódu se promítala se znatelnou prodlevou. Odpověď přišla kolem roku 2020 v podobě nástroje Vite, který staví na bleskově rychlém esbuildu (napsaném v Go) a na nativních ES modulech. Vývojový server tak naskočí prakticky okamžitě. Pomalé nástroje psané v JavaScriptu obecně začaly nahrazovat ty napsané v Go a Rustu, jako je třeba kompilátor SWC.

Vyvíjely se i samotné balíčkovací nástroje. Po npm přišel v roce 2016 Yarn se slibem rychlejší a deterministické instalace přes zámkový soubor, a po něm pnpm, který chytře šetří místo na disku tím, že balíčky neukládá pořád dokola. Pro projekty, které sdružují mnoho balíčků v jediném repozitáři (monorepa), zase vznikly nástroje jako Turborepo nebo Nx.

Éra SPA: prohlížeč se mění v platformu

Když měl JavaScript dost výkonu na klientu i na serveru, kyvadlo se prudce zhouplo směrem k prohlížeči. Nastoupila éra single-page aplikací (SPA): web, který se načte jednou a pak už si veškerou logiku, směrování i vykreslování řídí sám v prohlížeči, zatímco se serverem komunikuje jen přes API. Po průkopnících jako Backbone a Knockout přišly v roce 2010 AngularJS od Googlu, v roce 2013 React od Facebooku a v roce 2014 Vue od Evana You.

React přinesl dvě myšlenky, které předefinovaly frontend. První bylo komponentové myšlení: uživatelské rozhraní se skládá z malých, znovupoužitelných a do sebe vnořených kousků. Druhou byl virtuální DOM a deklarativní přístup — vy popíšete, jak má rozhraní vypadat pro daný stav, a knihovna se postará o to, aby skutečný DOM efektivně dohnala. „Mutuj data, ne DOM“ se stalo novou mantrou.

Pro JavaScript samotný byl zlomový rok 2015, kdy vyšla specifikace ECMAScript 2015 (ES6). Přinesla šipkové funkce, třídy, moduly, let a const, promises, šablonové řetězce a desítky dalších vylepšení, díky nimž se z jazyka napsaného za deset dní stal moderní, snesitelný nástroj. Od té doby vychází nová verze každý rok. Protože ale ne všechny prohlížeče uměly nové vlastnosti hned, prosadily se transpilery jako Babel, které moderní kód překládaly do staršího, a bundlery jako Webpack, které z desítek modulů poskládaly optimalizovaný balík ke stažení.

Reálný čas: WebSockety a konec modelu dotaz–odpověď

HTTP bylo od počátku postavené na modelu dotaz–odpověď: klient se zeptá, server odpoví a rozhovor končí. Pro živé věci — chat, notifikace, společné úpravy dokumentu — je to ale nešikovné. Server nemá jak sám od sebe poslat klientovi zprávu. První řešení byla spíš důmyslné triky: opakované dotazování (polling) a jeho chytřejší varianta, takzvaný long-polling, kdy klient nechával požadavek záměrně viset otevřený, dokud server neměl co poslat.

Skutečným řešením se staly WebSockety, standardizované v roce 2011. Ty mezi prohlížečem a serverem otevřou trvalé, obousměrné spojení, kterým si pak obě strany volně vyměňují zprávy. Pro jednosměrné posílání novinek ze serveru ke klientovi zase posloužila technologie Server-Sent Events. Najednou byly možné věci jako společné psaní v jednom dokumentu po vzoru Google Docs, živé dashboardy, hry pro více hráčů nebo chat fungující bez obnovování stránky.

Dnes už není reálný čas funkce navíc, ale očekávaný standard. Pokročilé techniky pro slučování souběžných úprav (CRDT) a hotové platformy umožňují stavět aplikace, ve kterých desítky lidí pracují nad stejnými daty zároveň, a změny se mezi nimi plynule synchronizují. Web se proměnil v místo, kde se společně tvoří, ne jen pasivně čte.

JavaScriptová únava: ekosystém, který přerostl sám sebe

Každá zlatá horečka má stinnou stránku. Kolem roku 2016 se začalo mluvit o „JavaScript fatigue“ — únavě z toho, že každý týden vychází nový framework, nový bundler a nová „jedině správná“ konfigurace, zatímco ta minulá už je zastaralá. Rozjet nový projekt znamenalo nastavit desítky nástrojů ještě dřív, než člověk napsal první řádek vlastní logiky.

Symbolem křehkosti celého ekosystému se stal incident left-pad v roce 2016, kdy jeden vývojář ve sporu stáhl z npm svůj jedenáctiřádkový balíček na doplňování mezer — a rozbil tím sestavení nesčetných projektů po celém světě, včetně velkých firem. Ukázalo se, jak hluboce je moderní web závislý na spletité síti drobných závislostí. Ve stejné době ale ekosystém přinesl i trvalé hodnoty: TypeScript od Microsoftu dodal JavaScriptu statické typování a postupně se stal de facto standardem pro větší projekty, a progresivní webové aplikace (PWA) se service workery umožnily webu fungovat offline a chovat se jako nativní appka.

Bezpečnost dospívá: HTTPS jako standard

Po většinu historie webu jezdila data po síti nešifrovaně. Protokol HTTPS býval vyhrazen jen pro přihlašování a placení, protože certifikáty stály peníze a jejich nastavení bylo otravné. Kdokoli na cestě mezi vámi a serverem — od provozovatele veřejné Wi-Fi po poskytovatele připojení — tak mohl provoz odposlouchávat nebo do něj zasahovat.

Zlom přišel v letech 2015 a 2016 se vznikem certifikační autority Let’s Encrypt, která začala vydávat důvěryhodné certifikáty zdarma a plně automatizovaně. Prohlížeče zároveň začaly nešifrované HTTP označovat jako „nezabezpečené“. Během několika málo let se většina veškerého webového provozu přesunula na HTTPS a ikonka zámečku se z výjimky stala normou.

Dospěly i další vrstvy obrany: pravidla CORS pro bezpečné požadavky napříč doménami, politika CSP proti útokům typu XSS, atribut SameSite u cookies nebo vynucování šifrovaného spojení přes HSTS. Bezpečnost přestala být něčím, co se dolepí nakonec, a stala se výchozím očekáváním zabudovaným přímo do platformy.

Kyvadlo se vrací: SSR, JAMstack a návrat statiky

Čisté SPA měly tři vážné neduhy. Vyhledávače dlouho neuměly dobře indexovat obsah generovaný až v prohlížeči, takže trpělo SEO. Uživatel se slabším telefonem zíral na prázdnou bílou stránku, dokud se nestáhl a nespustil velký balík JavaScriptu — to byl problém výkonu a doby do prvního vykreslení. A celá architektura byla zranitelná, pokud uživateli z jakéhokoli důvodu skript nedoběhl. Kyvadlo se proto začalo houpat zpátky k serveru.

Odpovědí bylo vykreslování na serveru (SSR) — server pošle hotové HTML, prohlížeč ho okamžitě zobrazí a JavaScript ho následně „oživí“ (hydratuje) do interaktivní podoby. Tenhle hybridní model zpopularizoval v roce 2016 Next.js postavený nad Reactem, jeho obdobou pro Vue byl Nuxt. Vznikla nová kategorie nástrojů — meta-frameworky, které vám neřeší jen vykreslování komponent, ale celou aplikaci včetně směrování, načítání dat a sestavení.

Souběžně se objevil zdánlivě paradoxní trend: návrat ke statickým stránkám, ovšem v moderním kabátě. Architektura JAMstack (JavaScript, API, Markup) stavěla na myšlence, že web lze předgenerovat do statických souborů při sestavení, rozmístit je po CDN a dynamiku dodat až za běhu přes API. Generátory jako Gatsby, Hugo nebo Eleventy, hostingy jako Netlify a Vercel a headless CMS oddělující správu obsahu od jeho zobrazení daly vzniknout webům, které byly bleskově rychlé a bezpečné, protože server, který by šel napadnout, vlastně neexistoval. Ironie dějin: po dvaceti letech jsme se vrátili ke statickým souborům — jen jsou teď generované a globálně distribuované.

Serverless: zapomeňte na servery

V roce 2014 představil Amazon AWS Lambda a uvedl do mainstreamu pojem serverless. Název je trochu zavádějící — servery samozřejmě existují dál, jen se o ně nestaráte vy. Místo abyste pronajímali a spravovali stroj běžící čtyřiadvacet hodin denně, nahrajete jednotlivou funkci a poskytovatel ji spustí jen tehdy, když přijde požadavek, automaticky ji škáluje od nuly do tisíců souběžných instancí a účtuje vám pouze skutečně spotřebovaný čas.

Pro web to znamenalo, že i tvůrce statického webu z JAMstacku mohl snadno přidat kousek backendové logiky — zpracování platby, odeslání formuláře, autentizaci — aniž by provozoval celý server. Souběžně dozrával svět kontejnerů: Docker (2013) standardizoval balení aplikací i s jejich prostředím a Kubernetes orchestraci těchto kontejnerů ve velkém. Architektura se drobila na menší, nezávisle nasaditelné kousky a infrastruktura se stávala kódem.

Kam s daty: od MySQL k NoSQL a edge databázím

Spolu s tím, kde běžel kód, se vyvíjelo i to, kde a jak se ukládala data. Éra LAMPu stála na relační databázi MySQL, vedle níž postupně dozrál výkonný open-source PostgreSQL, dnes pro mnohé výchozí volba. Aby vývojáři nemuseli psát ruční SQL dotazy, prosadily se objektově-relační mapovače (ORM), které dovolily pracovat s daty jako s objekty jazyka.

Kolem roku 2009 přišla vlna NoSQL. Dokumentová databáze MongoDB, rychlá klíč-hodnota cache Redis nebo distribuovaná Cassandra slibovaly volné schéma a snadné horizontální škálování, jaké si žádala doba cloudu a obřích objemů dat. Kyvadlo se ovšem nakonec zhouplo i tady zpět: relační databáze se naučily ukládat i JSON, a nabídly tak to nejlepší z obou světů.

V poslední době data následují výpočet až na okraj sítě. Globálně distribuované databáze a edge úložiště (například spravované platformy nad Postgresem, Cloudflare D1 nebo Turso) přibližují data uživateli a uzavírají kruh s edge computingem. Důvod je prostý: rychlý kód, který si pro data sahá do vzdálené databáze na druhém konci světa, je pořád pomalý.

Edge computing: výpočet se stěhuje za uživatelem

Serverless měl jeden háček, který nešlo obejít: rychlost světla. Pokud vaše funkce běží v datovém centru ve Virginii a uživatel je v Praze, každý požadavek absolvuje cestu přes Atlantik a zpět. CDN sice po světě dávno rozmisťovaly statické soubory blízko uživatelům, ale kód stále běžel centrálně. Logickým dalším krokem bylo přesunout i výpočet na okraj sítě — do stovek bodů přítomnosti (PoP) rozesetých po celém světě. Tomu se říká edge computing.

Průkopníkem se v roce 2017 staly Cloudflare Workers. Jejich technický trik byl zásadní: místo aby pro každou funkci spouštěly těžký kontejner nebo virtuální stroj, využily V8 isolates — lehké, izolované JavaScriptové kontexty uvnitř téhož procesu. Díky tomu odpadlo pomalé „studené spuštění“ známé z klasického serverless a funkce mohla naběhnout prakticky okamžitě, navíc v lokalitě nejblíž uživateli. Brzy přibyly konkurenční platformy — Vercel Edge Functions, Deno Deploy (opět od Ryana Dahla, autora Node.js) nebo Fastly Compute@Edge, který vsadil na WebAssembly.

Kód běžící na edge umí věci, které jsou centrálně nemyslitelné: rozhodovat o směrování a personalizaci podle země uživatele s nulovou latencí, vykreslovat stránku blízko návštěvníka nebo ošetřovat autentizaci ještě dřív, než požadavek vůbec dorazí k aplikaci. Takhle jednoduše vypadá kód reagující na geografickou polohu, který běží na okraji sítě:

export default {
  async fetch(request) {
    const zeme = request.cf?.country ?? "neznámá";
    return new Response(`Ahoj! Tvůj požadavek dorazil ze země: ${zeme}`, {
      headers: { "content-type": "text/plain; charset=utf-8" },
    });
  },
};Code language: JavaScript (javascript)

Klíčovým spojencem edge je WebAssembly (Wasm) — binární formát, do kterého lze zkompilovat Rust, C++, Go i další jazyky a spustit je v prohlížeči i na edge téměř nativní rychlostí. Wasm boří poslední dogma webu, že jediným jazykem je JavaScript, a otevírá dveře náročným výpočtům, hrám i portům desktopového softwaru přímo do prohlížeče. Rozhraní WASI pak Wasm modulům dává bezpečný přístup k systému i mimo prohlížeč, takže na edge může běžet izolovaný kód napsaný prakticky v jakémkoli jazyce.

Posun probíhá i o patro níž, na úrovni protokolů. Po dlouho neměnném HTTP/1.1 přišlo HTTP/2 s multiplexováním více požadavků přes jedno spojení a poté HTTP/3 postavené nad protokolem QUIC, který běží na UDP a lépe zvládá nestabilní mobilní sítě. Web je rychlejší nejen díky chytřejšímu kódu, ale i díky modernějším základům, po kterých ten kód cestuje.

Kde jsme dnes: renderuj, kde se to vyplatí

Dnešní situace je vlastně syntézou všech předchozích kapitol. Spor „server, nebo klient“ se rozplynul v pragmatické „obojí, podle toho, co se kde hodí“. Moderní meta-frameworky — Next.js, SvelteKit, Astro, Qwik nebo Remix, který v roce 2024 splynul s React Routerem — vám umožní v rámci jedné aplikace kombinovat statické předgenerování, vykreslování na serveru, běh na edge i klasickou interaktivitu v prohlížeči, a to často pro různé části jedné stránky zvlášť.

Z toho vyrostlo několik svěžích myšlenek. Architektura ostrovů (islands), kterou prosadil Astro, posílá na klienta převážně statické HTML a JavaScriptem oživuje jen ony malé interaktivní „ostrůvky“, čímž drasticky zmenšuje objem staženého kódu. React Server Components zase umožňují části komponentového stromu běžet a vykreslit se na serveru a nikdy se nedostat do balíku pro prohlížeč. Qwik experimentuje s resumabilitou — místo nákladné hydratace celé aplikace naváže prohlížeč přesně tam, kde server skončil. Všechny tyhle směry řeší tutéž věc: jak na klienta poslat co nejméně JavaScriptu a přitom zachovat bohatou interaktivitu.

A co dál: web ve věku umělé inteligence

Poslední tektonický pohyb přichází s umělou inteligencí a mění samotný způsob, jakým se web tvoří. Velké jazykové modely se zabydlely v editorech a z asistentů, kteří kód doplňují, generují a refaktorují, se stal každodenní nástroj. Práce vývojáře se posouvá od ručního psaní k zadávání, kontrole a směrování — což je proměna srovnatelná s tím, co kdysi znamenal příchod vyšších programovacích jazyků.

AI ale nemění jen vznik webu, mění i jeho podobu. Konverzační rozhraní, sémantické vyhledávání a generativní funkce se stávají běžnými prvky uživatelského rozhraní a volání jazykového modelu přes API je dnes skoro tak samozřejmé jako dotaz do databáze. I tady hraje roli edge — menší modely nebo směrování požadavků blízko uživateli zkracují odezvu. Je ovšem příliš brzy říkat, kde se kyvadlo zastaví. Pravděpodobně to dopadne jako u každé vlny předtím — od CGI přes AJAX a SPA po edge: nová technologie se nakonec vstřebá do základů webu, místo aby je nahradila.

Třicet let, a přesto pořád ten starý web

Když se na těch třicet let podíváte z odstupu, uvidíte ohromující pohyb — a zároveň pozoruhodnou stálost. Web prošel cestu od způsobu, jak sdílet fyzikální články mezi univerzitami, k celosvětové výpočetní platformě, na které běží banky, hry, redakční systémy i operační systémy. Výpočet se přestěhoval ze serveru na klienta, zpátky na server a nakonec se rozprostřel do distribuovaného kontinua s edge uprostřed. Frameworky vznikaly a zanikaly, kyvadlo se houpalo sem a tam.

A přesto: napíšete-li dnes do prohlížeče tři magické řádky HTML, fungují přesně tak jako v roce 1995. Stránka z dávných počátků webu se ve vašem nejnovějším prohlížeči stále načte. Tahle zarputilá zpětná kompatibilita — a otevřené standardy HTTP, HTML a URL, které ji umožňují — je tím nejcennějším, co web má. Je to důvod, proč web přežil každou technologickou módu, která ho měla nahradit, a proč téměř jistě přežije i ty příští.

Kyvadlo se houpe dál. A je docela vzrušující nevědět, kam se zhoupne příště.