Snelheid wordt meestal gezien als een taak voor engineers, en daarom wordt het vaak te laat aangepakt. Tegen de tijd dat iemand meet hoe snel een pagina is, zijn veel van de beslissingen die hem traag maakten maanden eerder genomen, in een designbestand, door iemand die nooit te horen kreeg dat die ze nam.
Het gratis PageSpeed Insights (opent in een nieuw tabblad) van Google laadt elke openbare pagina en somt op wat hem vertraagt. Een groot deel van wat het rapporteert, is geen programmeerfout. Het is een designbeslissing, doorgevoerd tot in de afgewerkte pagina.
De beslissingen die de grens bepalen
Drie dingen, vroeg gekozen, bepalen het grootste deel van wat een pagina ooit kan wegen.
De grote afbeelding bovenaan
Een foto over de volle breedte bovenaan een pagina is het grootste ding erop, en meestal het ding waar de browser op wacht voordat hij de pagina als geladen telt. Of die afbeelding een foto, een illustratie of een egale kleur is, was een designbeslissing, en die heeft meer invloed op de laadtijd dan alles wat een engineer daarna nog doet.
De lettertypen
Elk extra lettertype, en elke extra dikte ervan, is een bestand dat binnen moet zijn voordat tekst in de juiste vorm getekend kan worden. Twee lettertypefamilies met elk drie diktes is een beslissing die echte tijd kost op een trage verbinding. Niemand brengt het zo in de review, waar het een beslissing over toon is.
Of het eerste scherm afhangt van data
Een layout waarin de bovenkant van de pagina een persoonlijke begroeting is, kan pas verschijnen als de site heeft opgezocht wie je bent. Een layout waarin de bovenkant voor iedereen hetzelfde is, met het persoonlijke deel verder naar beneden, kan meteen verschijnen. Dat is een keuze over de layout, gemaakt in een designbestand, en die bepaalt of de pagina überhaupt vooraf klaargezet kan worden.
Deze dingen komen tijdens het ontwerpen niet als snelheidsvragen ter sprake, omdat snelheid pas later op de agenda staat. Dat is het echte probleem, en het is een variant van dezelfde kloof waarover ik schreef in de overdracht van design: het design komt compleet binnen, en de grenzen die het hadden moeten vormen, duiken daarna op als bugmeldingen.
Een verspringende pagina is een designbug
Layout shift is de naam voor een pagina die beweegt terwijl hij laadt: je wilt ergens op tikken en het springt weg. Van alles in een snelheidsrapport is dit het duidelijkst geen engineeringprobleem. Een pagina die beweegt tijdens het laden is misschien niet traag, maar wel frustrerend om te gebruiken, en het is vaak een deel van wat mensen bedoelen als ze zeggen dat een site goedkoop aanvoelt.
De oorzaak is bijna altijd dezelfde: er kwam iets binnen waarvan de grootte niet was vrijgehouden. Een afbeelding zonder bekende grootte. Tekst die eerst in een vervangend lettertype wordt getekend en daarna opnieuw, breder, in het echte. Een banner die boven de content wordt ingeschoven. Een advertentie. Een deel van de pagina dat niets laat zien en dan ineens wel iets.
Elk daarvan is op te lossen door de grootte vooraf te kennen, en de grootte vooraf kennen is iets wat design beslist. Als een kaart 180 of 260 pixels hoog kan zijn, afhankelijk van de lengte van een titel, dan is die variatie gespecificeerd, en die gaat iets kosten als de pagina laadt.
Een veelvoorkomende variant hiervan zijn afbeeldingen die op een andere site staan. Kopieer ze vooraf naar je eigen site en meet ze op, zodat de pagina de echte afmetingen heeft en precies de juiste ruimte kan vrijhouden voordat het bestand binnenkomt. Dit is een routineoplossing en geen slimme, en zonder deze oplossing herschikt het raster zich terwijl iemand ernaar kijkt.
Houd ruimte vrij voor alles wat kan ontbreken
Een sectie die leeg is en geen ruimte inneemt, en daarna vol raakt en 200 pixels inneemt, is dezelfde bug als een afbeelding zonder grootte. Als een sectie leeg kan zijn, beslis dan hoe hoog die is als hij leeg is, en beslis dat in het design in plaats van het op de live site te ontdekken.
Skeletons, en wanneer ze misleiden
Skeleton screens, de grijze blokken in de vorm van de content die je ziet terwijl een pagina laadt, zijn het standaardantwoord geworden op "wat laten we zien tijdens het laden", en vaak zijn ze het verkeerde antwoord.
Een skeleton is een belofte over vorm. Hij zegt: er komt content aan, die ziet er ongeveer zo uit, en die komt hier terecht. Als die belofte klopt, werkt het goed, omdat het oog al aan de layout gewend raakt voordat de content er is, en er niets verspringt als die er wel is.
Als de belofte niet klopt, is het erger dan een draaiend laadrondje. Drie skeletonrijen gevolgd door zeven echte rijen laten de pagina verspringen op precies het moment dat de content binnenkomt. Skeletonrijen gevolgd door "hier staat nog niets" is misleidend: de pagina suggereerde dat er content aankwam en liet daarna zien dat er geen is.
Twee regels hebben dit voor mij kloppend gehouden.
Gebruik een skeleton alleen als je de vorm kent
Als het aantal items onbekend is, is de vorm onbekend, en kan een skeleton er alleen naar gissen.
Gebruik geen skeleton voor iets wat snel is
Mijn vuistregel: als content binnen ongeveer 300 milliseconden binnen is, is een skeleton een korte flits die eruitziet als een storing, en niets laten zien is rustiger dan iets twee keer laten zien.
Een draaiend laadrondje is dus geen luie keuze. Voor een wachttijd van onbekende lengte en onbekende vorm is het de keuze die klopt.
Hoe snel een pagina voelt, is wat mensen merken
Gemeten snelheid en gevoelde snelheid verschillen vaak, en waar ze uiteenlopen, is het gevoel waar mensen over vertellen.
Een pagina die in 300 milliseconden haar structuur laat zien en de content in de 400 daarna invult, voelt sneller dan een pagina die 500 milliseconden niets laat zien en dan compleet verschijnt, ook al was de tweede eerder klaar. Er gebeurde iets, als reactie op iets wat ze deden, en snel. Dat is wat het snel laat voelen.
Dat leidt tot de nuttigste designbeslissing op de lijst: maak het statische deel van de pagina onafhankelijk van het trage deel. De header, het menu, de layout, de koppen en alles wat niet ergens anders vandaan gehaald hoeft te worden, moeten meteen kunnen verschijnen. Als ze op hetzelfde moeten wachten als het trage deel, wacht de hele pagina op het traagste onderdeel erin, en dat is een layoutbeslissing, geen technische.
Dezelfde logica geldt voor interactie. Een knop die reageert op het moment dat je erop drukt en een tel later met de server overlegt, voelt direct. Een knop die op de server wacht voordat hij laat zien dat hij is ingedrukt, kan kapot aanvoelen, zelfs als de vertraging kort is, en op een mobiele verbinding is die vaak niet kort. Of een actie kan reageren voordat die bevestigd is, is een designvraag over wat er gebeurt als het misgaat, en die moet in het design beantwoord worden, omdat het scherm voor als het misgaat een scherm is dat iemand moet tekenen.
Afbeeldingen zijn het meeste gewicht, en het grootste deel van de oplossing
Als een pagina zwaar is, dus groot in bestandsgrootte, komt dat meestal door de afbeeldingen en niet door de code.
De onderdelen die bij design horen en niet bij engineering:
Of de afbeelding er moet zijn
De effectiefste manier om een afbeelding kleiner te maken is hem weghalen, en een decoratieve foto die geen informatie draagt, is het makkelijkst te verwijderen ding op de pagina.
Hoe groot hij echt in beeld staat
Een afbeelding die 400 pixels breed wordt getoond, heeft geen bestand van 2000 pixels nodig. Veel live sites sturen afbeeldingen die veel groter zijn dan de ruimte waarin ze verschijnen, bijna altijd omdat niemand heeft vastgelegd op welke grootte de afbeelding getoond wordt.
Of hij zichtbaar is zonder te scrollen
Alles verder naar beneden kan later laden, als iemand ernaartoe scrolt, en kost vooraf niets. Alles erboven moet eerst binnen zijn. Die grens wordt in de layout getrokken.
Foto of illustratie
Een egale illustratie comprimeert tot een fractie van de grootte van een foto. Dat is een stijlkeuze met een gewicht eraan, en dat gewicht komt zelden ter sprake.
Het zichtbaar maken op een moment dat het nog uitmaakt
Wat de uitkomst verandert, is niet een bepaalde tool. Het is het getal ergens neerzetten waar een designer het ziet terwijl er nog tijd is om er iets mee te doen.
Een grens in de termen van het werk helpt meer dan een score. Google publiceert streefwaarden voor zijn Core Web Vitals (opent in een nieuw tabblad), zijn drie maten voor laden, reageren en layout shift: de grootste afbeelding of het grootste tekstblok op het eerste scherm hoort bijvoorbeeld binnen 2,5 seconde te verschijnen. Een team kan dat omzetten in grenzen waarbinnen een designer kan ontwerpen: de hoofdcontent verschijnt op een gewone telefoon binnen die tijd, de afbeeldingen die je zonder scrollen ziet blijven onder een grootte die het team afspreekt, niets beweegt meer zodra de pagina verschenen is. Een score op honderd, geleverd nadat het design is overgedragen, is een cijfer voor werk dat al af is.
En het meten moet gebeuren onder de omstandigheden waarin mensen de site echt gebruiken. Een design dat op een snelle laptop via de kantoorwifi is beoordeeld, is beoordeeld onder omstandigheden die de meeste gebruikers niet hebben. Browsers kunnen een trage mobiele verbinding nabootsen (de ontwikkelaarstools van Chrome hebben daar een instelling voor). Probeer het één keer op een pagina die je net hebt goedgekeurd, en wat er moet veranderen, wordt meteen duidelijk.
Het deel dat moeilijk te accepteren is
Snelheidswerk is vooral dingen weghalen, en dingen weghalen is niet wat designreviews belonen. Een pagina met één lettertype, geen grote foto bovenaan en geen intro-animatie laadt snel en kan eruitzien alsof niemand zijn best heeft gedaan.
Ik denk niet dat het antwoord is om alles uit te kleden. Het is dat de kosten zichtbaar moeten zijn op het moment van kiezen, zodat een tweede lettertype of een foto over de volle breedte iets is waar je bewust aan besloot uit te geven, en niet iets wat in een rapport opdook als het probleem van iemand anders. Elke snelheidsbeslissing die het waard is om te nemen, is een afweging, en het is pas een echte afweging als je de kosten ziet wanneer je hem maakt.