Grand Unification of Web Technologies Proposal

The way web currently function in a browser: you can start with a simple piece of text readable everywhere and smoothly progress it up to a full blown application step by step. It is insanely creative and powerful paradigm that can be successfully used by everyone starting with my cat and ending with some genius programmer/artist/insert your own here.

Sure it is a mess if one wants to look for a mess but it benefits far outweigh its many problems.

Myself I mostly design native applications and servers but when I need to put some web fronts I am pleased on how relatively easy everything is (no I do not use giant web frameworks).

So back to the author of original article. In my opinion it is very arrogant, incompetent and naive (at best) piece.

> A lot of the web is already just javascript. Looking at "appification" and throwing our arms up in the air is just a form of giving up.

Yes, this certainly /feels/ like the trend. Yet folks like Github and Youtube and Microsoft are busy building a better web that does re-center & re-emphasize the DOM, by adopting & driving WebComponents forward.

It's weird to me that there is such a sizable disconnect: that a lot of very big very large players have adopted good web technology, but that so much of the world hasn't caught on, doesn't see it, doesn't know how they'd do it themselves. The lessons, of what large scale application design look like in such an environment, have not started disseminating out. The tools are there, but visualizing how they come together to make a web app, that's still fairly mysterious. But being done at very large scales, seemingly quite effectively.

> Rather, we should find ways to ensure that whatever direction the web takes, we can keep building powerful tools to foster the creativity and agency you and I have today, and push them to the hands of the mainstream.

:hands-up: Very nicely said.

I agree with the general principle of this document: HTML is outdated and there should be a unification of web technologies so the web becomes easier to build on.

My solution to this problem is to upgrade HTML, a language with a syntax I love, so it can handle building full-stack, interactive web apps instead of just plain documents.

I recently released my version of this idea as an open-source web app framework called Remake [0]. I could really use some help from contributors to make this new approach to building web apps even better. It's not meant to replace other stacks, but to complement them as an easy-to-learn, quick-to-build-with alternative.

Large parts of its infrastructure were inspired by some excellent critiques of SPAs from this very message board:

- It's a server-rendered framework (doesn't need front-end JS at all if a user is viewing a page they can't edit)

- It uses plain HTML, CSS, and JS to build out functionality (no transpilers and only the simple Handlebars.js templating language). You don't need a million tools to get started.

- It uses a file-based JSON datastore so it's easier for devs to use and manipulate data

- It uses file-based routing, so there's no complex hierarchy of pages and a standard structure to URL params

- It feels like, to me, the gold standard of web development: using a single templating and behavior-rich language on the front-end, and a simple JSON file for each user that's synced to and loaded automatically on the backend

I've been building it and documenting it [1] mostly on my own, although I've gotten a few other devs to help me along the way. I really think it could be a great framework for beginners as well as experienced developers who want to release small side projects quickly.

I've built several example apps with it so far and they're pretty powerful. I'd love to know what the HN audience thinks though.

[0] https://remaketheweb.com/ [1] https://docs.remaketheweb.com/

I miss late 90s computing: native apps, with HTML as a document format rather than a VM. You could do interesting things outside of the google/http straightjacket. But none of that matters.

We have miscegenated disgusting javacript with the disgusting DOM, and we have filled the earth with it. It will be here forever! Like COBOL, but many orders of magnitude worse.

eBPF and rust show that it's possible to require programs to have certain provable properties, and still have enough flexibility to write really useful programs. WASM already avoids certain classes of bugs by controlling memory layout. And browsers warn if a JS script runs too long. We don't have to make software completely declarative to have safety guarantees.