I suspect they are both more familiar with client-side rendering, and also thinking of things being able to share components, reuse existing libraries, and so on. So re-implementing everything with vanilla HTML and forms feels like reinventing the wheel to a team used to an SPA component library, it's not that it's intrinsically harder, it's that they don't have the existing building blocks they'd normally reach for.
Modern frameworks such as Astro allow for a similar development experience (and can optionally use JS, React and other client-side libraries) while still being able to generate a static site if desired.
I think server-side rendering and static site generation are less familiar to many web devs who came up in the React/Vue/Svelte era. The patterns and mental model are just different. In an ideal world we combine both: fast static HTML that works everywhere, with progressive enhancement for interactivity. Astro does this well; Next.js supports it too, though the SSR parts have a learning curve.
Nice work! I've enjoyed playing this game in the past, and have been working on porting various apps to wasm lately. Coincidentally, this is one I was looking into porting when I found this post.
Part of the threat model is that individual orgs can be compelled in various ways to turn over individual user data, and having different orgs holding their own private keys helps to mitigate this.
As bad (and deserved) as their reputation is for helping well-meaning users to create a big mess, spreadsheet software provides an incredibly intuitive UI to put in front of users that have the domain knowledge but not necessarily direct software engineering knowledge.
I've been thinking about this for years, ever since I first read "A Small Matter of Programming" by Bonnie Nardi: https://mitpress.mit.edu/books/small-matter-programming where she explored the history of end-user programming systems, and concludes that spreadsheet and CAD software are the only examples that have had widespread and undeniable success.
ASMOP was published in 1993 and I think it is still just as relevant today.
Just as it's possible to write a terribly-architected and designed program in any language, I suspect that with the right engineering effort and insight, modern software engineering practices could bring the complexity under control.
We shouldn't expect to just take spreadsheets and stick them into production, just as you wouldn't take a hastily-written prototype written in any programming language and do the same.
I just tried and appears to work OK (Firefox 61.0.1, macOS)... since it's unsigned I loaded it as a temporary add-on in about:debugging
plibither8, would you mind adding instructions to load this into Firefox in your README as well as Chrome? Also please upload to addons.mozilla.org as well as the Chrome Store.
There's interest in wasm-land about having "non-web embeddings", which wouldn't assume things like JS APIs exist at all.
I think in that sort of world, you could probably find nicer APIs to target than WebGL and WebAudio... however if you don't mind still having a JS interpreted available then it'd probably be easy to build this sort of thing today using Node.
> Easier implementation is the goal. There are currently only four companies working on a web implementation.
Easier implementation of a browser? You might find it interesting to see what Servo has chosen to implement and what they have not. Some things you'd think would be easily removable (such as document.write) turn out to not be so simple to skip.
One of the most valuable things about the Web is the care taken around backwards compatibility.
I do think it'd be quite interesting if you had a user agent that did the DOM differently (not sure what you have in mind specifically re: "documents didn't automatically gain the same privileges as applications") and focused just on providing a GL canvas and audio APIs.
I think you might find that these APIs aren't quite as nice when it comes to re-implementing things that CSS and DOM make easy, and it'd be hard for such a browser to really compete with existing browsers given the backwards-compat situation on the web (mandating GL would leave some devices behind, and web authors as a whole don't really adapt all that quickly).
In any case I think it might still be useful as a reference implementation / proof-of-concept on how minimal a web user agent can be, if it was just focused on hosting applications.
You could probably do this now as a standalone Node app, if you want more explicit control over which APIs are available and where code can be run from.
The browser is indeed quite complex (and not just because of the massive historical baggage), but its job is to give the user control while safely downloading untrusted code and running it locally.
So, if your goal is to just have a simple standalone app I think you could stay largely compatible with APIs available in the browser environment.
Modern frameworks such as Astro allow for a similar development experience (and can optionally use JS, React and other client-side libraries) while still being able to generate a static site if desired.
I think server-side rendering and static site generation are less familiar to many web devs who came up in the React/Vue/Svelte era. The patterns and mental model are just different. In an ideal world we combine both: fast static HTML that works everywhere, with progressive enhancement for interactivity. Astro does this well; Next.js supports it too, though the SSR parts have a learning curve.