rhelmer

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.

Anyone used this and could compare/contrast with web-ext https://github.com/mozilla/web-ext ?

I worked on the Firefox integration (per the article) if anyone has specific questions.

If you want more detail on Prio itself, I'd suggest http://blog.ezyang.com/2017/03/prio-private-robust-and-scala... as a more gentle introduction than the research paper.

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.

Ah, missed that. Cool.

This is only being served to Release channel users currently (per the bug in the extension ID, https://bugzilla.mozilla.org/show_bug.cgi?id=1487578)

ESR users are on a separate channel.

Would you mind pasting your `about:support` somewhere (github gist, pastebin, etc) and linking it here?

The intent was to express publicly, and then send an update that reflected this.

Would it feel less "[sneaked] in" if this were a core feature in Firefox?

If you are seeing something different please let me know!

If I am understanding correctly, these are two separate things:

- https://my.mixtape.moe/sjlprj.jpg - this is whether data is reported to mozilla servers

- https://my.mixtape.moe/sflqrh.jpg - this is data collected locally

You can see the latter in `about:telemetry`

This was actually discussed on HN previously, with a link to the text: https://news.ycombinator.com/item?id=17797003

In case anyone is curious why this works, Firefox switched to a new extensions API which tries to stay compatible with the one Chrome uses:

https://developer.mozilla.org/en-US/Add-ons/WebExtensions

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.

Nice work!

Huh! I wouldn't expect that at all... here are some easy things to try:

https://support.mozilla.org/en-US/kb/firefox-uses-too-many-c...

If it is still happening after you try those, use https://perf-html.io/ and share a profile.

Ah, ok. That's interesting too!

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.

https://mycroft.ai might be a viable option - I believe they are planning to use Mozilla's speech recognition work too.

One problem is the risk of self-selection bias.

While I agree that reading source code is quite useful and informative, it really is no substitute for reverse engineering and inspecting on actual hardware.

It's quite easy to be mislead by source code, especially if you're trying to guess what output the compiler will actually generate.

As the author mentions elsewhere in this thread, both reading the source and reverse engineering (inspecting output, running under debugger, etc) are ideal.

> I'm not sure why content creators are feeling the need to go multi-media

I was around for BBSes and the early public internet, and I do appreciate text interfaces... that said, I've always felt there was something quite magical about graphics and audio. The web allows the author quite a bit of freedom in this regard, so it ends up pretty chaotic and uneven.

I find that graphics help to get a point across quickly, even for folks who are very comfortable with tons of text (most people in the world really aren't, and the language you prefer is likely not their first anyway so it's quite a bit of work for them)

It can be misused just like anything else, and tastes can be subjective. It's nice, then, that web browsers being at their core agents for the user, you can also get a fair bit of control on what you want to block by default, or have animations be click-to-play, and so on, which override the author's design.

This post suddenly reminded me of Resolver Systems, who made a Python/.Net spreadsheet back in the '00s:

http://www.prweb.com/releases/spreadsheet/competition/prweb1...

I thought it was a good idea at the time, especially after having read "A Small Matter of Programming" which makes the case that spreadsheets are one of the very few successful end-user programming systems (the other being CAD):

https://mitpress.mit.edu/books/small-matter-programming

This use case is interesting to me too. I looked into this a few months ago and found that there is a page on non-web embeddings:

http://webassembly.org/docs/non-web/

Yes, it was announced in https://blog.mozilla.org/addons/2016/07/29/extension-signing...

In the book "A Small Matter of Programming"[0] (1993), Bonnie A. Nardi makes the case that there are really only two successful end user programming systems - spreadsheets and CAD.

I think that's just as true today, at least as far as business software goes.

0 - https://mitpress.mit.edu/books/small-matter-programming

Well the context in this case (per the article) is the workplace, and the article appears to focus on the US, to disambiguate the laws and norms expected.

At work?

Catcalling just seems like a bad example... I can't think of a situation where that seems appropriate?

I'm really not seeing why any of this belongs in the workplace. Why not bars, or if you're not the nightlife type, dating sites?