[bitmapbrother]

How exactly did Mozilla win this fight? WebAssembly was inspired by Mozilla's asm.js and Google's PNaCl. Also, the team working on WebAssembly are from Mozilla, Microsoft, Google and Apple. The real winner here are users because we now have a standard among all major browsers.

[roca]

Google developed NaCl and PNaCl and put the latter out on the Web with no spec --- just "pull this version of LLVM and ship it". Also, apps written in PNaCl used the Pepper API for all platform features, a giant pile of Chromium code also with no spec. All an absolute nightmare for anyone who cares about Web standards and browser bloat. These efforts required big Google teams working for many years ... efforts which are now going by the wayside.

Mozilla put together a small team and did asm.js to show that you could port C/C++ apps to the Web and get good performance while reusing the JS engine and all the existing Web platform APIs.

Now we have WebAssembly, which uses existing Web platform APIs and which browser vendors are implementing by reusing the guts of their JS engines. It's obvious who won.

In a way it doesn't matter "who won" because as you say Web developers are the ultimate winners. But it does underscore how much the Web continues to owe to Mozilla.

(It's also an illustration of how powerful companies can commit massive blunders and get away scot-free in the marketplace and in PR.)

[dragonwriter]

There's no blunder: Google had a goal, threw out something, stimulated competition over the precise implementation, and now there is a universally (among browser vendors) accepted solution moving the web in the direction Google wanted.

That's a strategic victory for Google.

[roca]

Google wasted huge resources on an approach which it was obvious from the beginning would never lead to a Web standard. Mozilla people, including me, told Google people even before PNaCl appeared that introducing the whole new non-standard Pepper API was unacceptable.

[sangnoir]

> Google wasted huge resources on an approach which it was obvious from the beginning would never lead to a Web standard

Google has been doing this for a long time, I doubt it's unintentional. If there is functionality that they want which is not standardized, they go ahead and implement it. When a workable standard is ready or detailed enough, they switch over to it. The earliest instance of this that I can recall was Google Gears, which was deprecated by LocalStorage. There probably are earlier examples.

[roca]

Sure but the asm.js/Wasm approach was always an option. They didn't have to go down the path they did.

[sangnoir]

NaCl predates asm.js/Wasm by 2 years: it wasn't always an option

Here's a timeline:

  2011-10-16: Native client released
  2013-03-21: asm.js released
  2013-06-25: Firefox 22 released with asm.js support
  2013-07-17: Chrome 28 released with optimizations for asm.js
  2015-06-17: WebAssembly released
  2017-06-30: Google announces switch to Wasm.

When do you think was a Good time for Google to switch tracks?

[johncolanduoni]

Was it an obvious option? I don't think I'd give the asm.js and WebAssembly developers so little credit.

[a3_nm]

> If there is functionality that they want which is not standardized, they go ahead and implement it.

... in a non-standardizable way.

Why not try to help create a standard instead? What's the benefit of starting with a dirty approach and deprecating it later?

[indy]

It's best to have couple of working/competing implementations first before defining a standard.

[sangnoir]

> Why not try to help create a standard instead?

They do that as well, it's not one or the other. Google had employees working on WebAssembly (along with Mozilla, Apple and Microsoft). Standards take time to be developed and finalized.

[hawski]

Because people prefer something broken now then something good later.

[dragonwriter]

> Google wasted huge resources on an approach which it was obvious from the beginning would never lead to a Web standard.

But it did lead to a web standard, even if it didn't become one. And in the interim, it provided utility to Google.

> Mozilla people, including me, told Google people even before PNaCl appeared that introducing the whole new non-standard Pepper API was unacceptable.

Yeah, you've mentioned that quite a few times. So what? Unacceptable nonstandard moves are a big part of what stimulates standards progress.

[roca]

If spending any amount of resources to get any amount of utility counts as success, then there is no such thing as failure.

[will4274]

Google makes money from the web. Massive amounts of money. Something like 93% of their revenue. If WebAssembly leads to the decline of mobile apps, the amount of resources that Google spent on PNaCl is so tiny compared to the amount they will make by continuing to own the world of online advertising.

[StavrosK]

Just so I get your argument straight, you're saying that launching a proprietary competitor to the standard means you're helping the standard?

Because then we owe Microsoft and Apple a shitload of thanks.

[dragonwriter]

> Just so I get your argument straight, you're saying that launching a proprietary competitor to the standard means you're helping the standard?

No, I'm saying that launching a nonstandard solution to a problem without a standard solution or where there are discontents with the standard that are not being addressed is the usual way new standards are motivated, whether the new standard is based on the nonstandard solution or developed in reaction to it.

Standards (and even moreso, standards that are actually implemented rather than being mere paper triumphs) somewhat backward-looking rather than out-of-the-blue.

A commitment to standards isn't about not implementing nonstandard things, it's about engaging in the standards process to help get to a robust standard and then implementing it (replacing nonstandard solutions, if any) when it is clear what the consensus standard will be.

(And I use "nonstandard" rather than "proprietary" because standard/nonstandard is a different axis than open/proprietary.)

> Because then we owe Microsoft and Apple a shitload of thanks.

Well, yes, a lot of current web standards were originally either nonstandard solutions from Microsoft or Apple or alternatives developed in response and motivated by such nonstandard solutions, so, sure, they've driven a lot of the progress. I think they've generally been less good about (at last, slower) participating in standardization of an alternative when their original solution isn't acceptable to other players, but they have definitely been change drivers.

[jamespo]

This is very close to "4D chess" reasoning

[_0w8t]

The problem was precisely the Pepper, a pile of API that Google thought they could force on everybody, not PNaCl per see. If the initial NaCl implementation just exposed the pre-existing Web API into the native code sandbox without adding anything extra, the story can be rather different and a version of PNaCl could be standardized.

[roca]

That's true, although NaCl's design made that difficult because the native code sandbox had to be a different process so interacting with the page's DOM would have required IPC.

[_0w8t]

I am curious what made it necessary to run NaCl in a different process? I thought the main idea behind NaCl was to allow the same-process native sandboxes.

[m12k]

Reminds me of Cunnigham's Law: "the best way to get the right answer on the internet is not to ask a question; it's to post the wrong answer."

[bfred_it]

I love that law. I've been putting it to use ever since I read that.

[camgunz]

There's no denying Mozilla played a huge role, but PNaCl was an critical step away from "JS as the bytecode of the web". That approach simply couldn't compete with mobile platforms running on (more or less) native code.

[withjive]

What you said is true, however...

I am referring to the initial offering of Native Client for inclusion into FireFox.

Since this did not happen, Native client did not see the uptake it needed— and the team was destaffed.

Since it was a working platform that actually existed and let you use a modified version of LLVM, it was quite usable.

We could of have powerful native sandboxed apps quite a long time ago if FireFox became PNaCl compatible.

Instead, Mozilla envisioned that the JIT could eventually bridge the native performance gap.

Mozilla defended this ideas such as ASM and emscripten. And now Mozilla is coming close to a more open and performant web.