When discussing new features for the web we often distinguish between low-level and high-level features. I'll leave defining what these are for another day. However, we usually think of high-level APIs are being the (hopeful) end-game of years (often decades) long work where low-level primitives are discovered and implemented until we have everything we need to build a pristine high-level API that makes everything super easy.

There's a feeling of deserved accomplishment when a high-level feature makes it onto the web; they are so hard to do. Without negating the accomplishment it's important to also realize even within the high-level category, some APIs are transformational whereas others are simply useful within their narrow use-case.

So with this post let me introduce a new concept I hope we all adopt: the transformational feature. Roughly I distinguish between high-level and transformational features in this way:

  • A simple high-level feature makes it easy to accomplish something. For example the border-radius property makes it easy to do something that was almost not possible before.
  • A transformational feature is one that changes the way you develop or design. They are not distinct in any other way, and you might not even recognize how important they are until you take a step back and look.

Note that a transformational feature is not necessarily also a high-level feature. Although often the case, it's possible and some times even desired that higher-level concepts be built on top. What's key to the transformational feature is, as stated above, that it allows new development paradigms to form.

For illustration, some transformational features in the recent 10 years or so (I would argue) include:

  • CSS Grid - To me the definitive transformational feature. Grid simply makes you change the way you develop a front-end by dramatically simplifying a part of design that used to dominate attention. It went from essentially requiring the use of a CSS framework to not needing one at all, overnight.
  • CSS Custom Properties - The ability to dynamically change things in a programming language is a major milestone. This is a sneaky one because on the surface it seems to formalize what was already being done in preprocessors, but the ability to dynamically adopt to variable changes elsewhere in the DOM structure and stuff like Space Toggle that allows boolean logic to be performed.
  • Custom Elements - Whether you use them yourself or not, the ability to participate in HTML rendering massively simplifies embedding custom logic in any web page.
  • JavaScript Modules - The introduction of modules (even way before browsers supported them) made code organization something you could actually think about and achieve on the web.
  • WASM* - With an asterisks as this hasn't been fully proven out yet, but WASM certainly has the potential to change how a certain category of applications are built.

And a few potential transformational features that are on the horizon but not quite here yet:

  • Container Queries - The ability to adapt the size of a component based on how much space it has available.
  • Portals - Portals hope to bring more seamless page transitions to traditional multi-page applications. This has the potential to be a major innovation that brings some capabilities that only the Single-Page Architecture currently has, to the web's default mode of pages.

So why bring this idea up? I think it's important to recognize that while all high-level features are welcome, there is this other category that is extremely important as well.

It's vital that some times the platform does bring about transformational features, because it is these that free developers from constraints and allow them to move their minds to other areas. This is what allows the quantum leaps in web development to occur.

Throughout the history of the web I imagine you'll see peaks and valleys where transformational features come in spurts. Currently I feel we are in somewhat of a valley, particularly among HTML transformational features, which has glaring deficiencies compared to native platforms but little hope for big changes within the near (or even mid) future.