Portals and giant carousels
Tags: portals, spas, standards, browsers
Published: 2020-11-10 10:01:49

---
title: Portals and giant carousels
published: true
date: 2020-10-28 15:32:31 UTC
tags: portals,spas,standards,browsers
canonical_url: https://adactio.com/journal/17573
---

[I posted something recently](https://adactio.com/notes/17548) that I think might be categorised as a “shitpost”:

> Most single page apps are just giant carousels.

Extreme, yes, but perhaps there’s a nugget of truth to it. And [it seemed to resonate](https://twitter.com/fakebaldur/status/1319232156997242880):

> I’ve never actually seen anybody justify SPA transitions with actual business data. They generally don’t seem to increase sales, conversion, or retention.
> 
> For some reason, for SPAs, managers are all of a sudden allowed to make purely emotional arguments: “it feels snappier”
> 
> If businesses were run rationally, when somebody asks for an order of magnitude increase in project complexity, the onus would be on them to prove that it proportionally improves business results.
> 
> But I’ve never actually seen that happen in a software business.

A single page app architecture makes a lot of sense for interaction-heavy sites with lots of state to maintain, like twitter.com. But I’ve seen plenty of sites built as single page apps even though there’s little to no interactivity or state management. For some people, it’s the default way of building anything on the web, even a brochureware site.

It seems like there’s a consensus that single page apps may have long initial loading times, but then they have quick transitions between “pages” …just like a carousel really. But I don’t know if that consensus is based on reality. Whether you’re loading a page of HTML or loading a chunk of JSON, you’re still making a network request that will take time to resolve.

The argument for loading a chunk of JSON is that you don’t have to make any requests for the associated CSS and JavaScript—they’re already loaded. Whereas if you request a page of HTML, that HTML will also request CSS and JavaScript.

Leaving aside the fact that is literally what the browser cache takes of, I’ve seen some circular reasoning around this:

1. We need to create a single page app because our assets, like our JavaScript dependencies, are so large.
2. Why are the JavaScript dependencies so large?
3. We need all that JavaScript to create the single page app functionlity.

To be fair, in the past, the experience of going from page to page used to feel a little herky-jerky, even if the response times were quick. You’d get a flash of a white blank page between navigations. But that’s no longer the case. Browsers now perform something called [“paint holding”](https://developers.google.com/web/updates/2019/05/paint-holding) which elimates the herky-jerkiness.

So now if your pages are a reasonable size, there’s no practical difference in user experience between full page refreshes and single page app updates. Navigate around [The Session](https://thesession.org) if you want to see paint holding in action. Switching to a single page app architecture wouldn’t improve the user experience one jot.

Except…

If I were controlling everything with JavaScript, then I’d also have control over how to transition between the “pages” (or carousel items, if you prefer). There’s currently no way to do that with full page changes.

This is the problem that Jake set out to address in his [proposal for navigation transitions](https://github.com/jakearchibald/navigation-transitions) a few years back:

> Having to reimplement navigation for a simple transition is a bit much, often leading developers to use large frameworks where they could otherwise be avoided. This proposal provides a low-level way to create transitions while maintaining regular browser navigation.

[I love this proposal](https://adactio.com/links/12885). It focuses on user needs. It also asks _why_ people reach for JavaScript frameworks instead of using what browsers provide. People reach for JavaScript frameworks because browsers don’t yet provide some functionality: components like tabs or accordions; DOM diffing; control over styling complex form elements; navigation transitions. The problems that JavaScript frameworks are solving today should be seen as the R&D departments for web standards of tomorrow. (And conversely, I strongly believe that [the aim of any good JavaScript framework should be to make itself redundant](https://adactio.com/journal/17309).)

I linked to Jake’s excellent proposal in [my shitpost](https://adactio.com/notes/17548) saying:

> bucketloads of JavaScript wouldn’t be needed if navigation transitions were available in browsers

But then I added—and I almost didn’t—this:

> (_not_ portals)

Now you might be asking yourself what [Paul said out loud](https://twitter.com/paulrobertlloyd/status/1319272673164156930):

> Excuse my ignorance but… WTF are portals!?

[I replied](https://adactio.com/notes/17549) with a link to [the portals proposal](https://github.com/wicg/portals) and what I thought was an example use case:

> Portals are a proposal from Google that would help their AMP use case (it would allow a web page to be pre-rendered, kind of like an iframe).

That was based on my reading of the proposal:

> …show another page as an inset, and then activate it to perform a seamless transition to a new state, where the formerly-inset page becomes the top-level document.

It sounded like Google’s top stories carousel. And the proposal goes into a _lot_ of detail around managing cross-origin requests. Again, that strikes me as something that would be more useful for a search engine than a single page app.

But [Jake was not happy with my description](https://twitter.com/jaffathecake/status/1319283807250305027). I didn’t intend to besmirch portals by mentioning Google AMP in the same sentence, but I can see how the transitive property of ickiness would apply. Because Google AMP is a nasty monopolistic project that harms the web and is an embarrassment to many open web advocates within Google, drawing any kind of comparison to AMP is kind of like Godwin’s Law for web stuff. I know that makes it sounds like I’m comparing Google AMP to Hitler, and just to be clear, I’m not (though I have myself [been called a fascist](https://adactio.com/notes/15670#comment74368) by one of the lead engineers on AMP).

Clearly, emotions run high when Google AMP is involved. I regret summoning its demonic presence.

After chatting with Jake some more, I tried to find a better use case to describe portals. Reading the proposal, portals sound a lot like “spicy iframes”. So here’s a different use case that I ran past Jake: say you’re on a website that has an iframe embedded in it—like a YouTube video, for example. With portals, you’d have the ability to transition the iframe to a fully-fledged page smoothly.

But Jake told me that even though the proposal talks a lot about iframes and cross-origin security, portals are conceptually more like using `rel="prerender"` …but then having scripting control over how the pre-rendered page becomes the current page.

Put like that, portals sound more like Jake’s original navigation transitions proposal. But I have to say, I never would’ve understood that use case just from reading the portals proposal. I get that the proposal is aimed more at implementators than authors, but in its current form, it doesn’t seem to address the use case of single page apps.

[Kenji said](https://twitter.com/KenjiBaheux/status/1319387992994181120):

> we haven’t seen interest from SPA folks in portals so far.

I’m not surprised! He goes on:

> Maybe, they are happy / benefits aren’t clear yet.

From my own reading of the portals proposal, I think the benefits are definitely not clear. It’s almost like the opposite of [Jake’s original proposal for navigation transitions](https://github.com/jakearchibald/navigation-transitions). Whereas as that was grounded in user needs and real-world examples, the portals proposal seems to have jumped to the intricacies of implementation without covering the user needs.

Don’t get me wrong: if portals somehow end up leading to a solution more like Jake’s navigation transitions proposals, then I’m all for that. That’s the end result I care about. I’d love it if people had a lightweight option for getting the perceived benefits of single page apps without the costly overhead in performance that comes with JavaScripting all the things.

I guess [the web I want](https://webwewant.fyi/) includes giant carousels.