Hacker News Reader

Comment by madez | Hacker News Reader

WebAssembly is yet another approach to withhold the source of programs from the ones that interact with it.

By just sending part of the necessary binary logic to the user, it is ensured they can't easily be independent of the provider or create their own solution.

If someone doesn't see what I'm talking about, then read about the AGPL; it exists to prevent what I'm talking about.

Superficially, it is a shame Mozilla is working on this technology. However, it's official goal is to advance "The Web"©® which uses above mentioned effects to lead to centralization and lack of freedom for users.

WebAssembly and some other modern browser features are the basis for the massive centralized providers we have today. That "The Web" leads to decentralization is a lie.

View on HN

This is a pretty ridiculous response. There have been compiled languages way before interpreter/jit ones and these didn't halt the advancement of programming and programming communities, especially the sharing code and ideas part.

Also you shouldn't need access to code to create your own solution. Many people have been reverse engineering or borrowing from ideas in the compiled world. When I copy something I like I don't typically look at their code, I focus on the functionality and break down what its doing so i can reimplement it.

The fact you are focusing on centralization is basically saying "i can't steal someone eases code". The web promised to be free and open and that had nothing to do with whether or not you could read the javascript.

Most modern javascript on site is rather unreadable due to being transpiled anyways. There is still an option to use plain javascript instead of WASM. Just like now you can use plain javascript instead of transpiling it.

There are people that lobby for closed source and distribute closed source, and there are people that lobby for floss and libre software. And then there are hypocrites.

Mozilla is bathing itself in it's image of standing for a free and open world. The truth is that it's business in "The Web" is creating the groundwork for a closed and non-free world. This hypocrisy cries out deafening.

Mozilla is also realising that the web needs to compete with native apps as well. Note that it's even easier to hide the source of native apps.

(Furthermore, many apps that would use WASM probably have a significant server-side part as well that is not necessarily open source.)

At least native applications are something static you can verify. With web 'apps' like, say, anything based on electron, the end user has no control about what code is run. Instead the 'app' just pulls down and runs whatever the company/etc wants you to run dynamically and differently every time with the permissions you gave originally.

Your mention of Electron is the perfect example of why this is no different for native apps. Of course, on mobile this is usually mitigated through app stores, but there is no reason similar mechanisms could be introduced for the web if this really turns out to be problematic.

Electron is not a native app. Electron is a browser web app marketed as a native application.

The only reason it's got all those permissions is because it is a native app, which can claim all those permissions. Sure, Electron app are browser wep apps marketed as a native application, but by definition, native apps can do everything Electron apps can do.

Chrome browser is only 50% of Electron. The other 50% is a complete nodejs distribution which allows access to the OS filesystem, network, anything Java or .NET can do on a desktop... So no, it's not just a browser web app. Electron is absolutely native to the OS is runs on.

A language being compiled or not has nothing to do with the web being free.

Like I said we can already pretty much transpile our code to practically speaking, an unreadable state.

Companies can already choose to make their code closed source and transpile it. If there goal is to make it more closed they can do that now.

WASM doesn't change that. People can still make their code open source, they can still write in plain javascript. Its really no different. Instead we are giving people options and the ability to have more performant apps in the ones that require it.

>The web promised to be free and open and that had nothing to do with whether or not you could read the javascript.

This had and has everything to do with it. Please, read what you have just written, and think.

Companies can develop big, bulky WASM-only framework with graphic primitives & so on, very much like Java applets, and effectively kill the openness of the web standards.

> have been reverse engineering

Reverse engineering some HTML is not difficult. Minified JS is much more difficult. A 50MB blob of WAMS is just too time consuming.

> The web promised to be free and open and that had nothing to do with whether or not you could read the javascript.

On the contrary, making it 100x times more difficult to understand what a website is doing is terrible for security, compatibility, inclusiveness (good luck making a braille terminal for WASM-only websites or using them on a very slow uplink)

Is minified JS fundamentally different? JS is already used as a write-only compilation target, and wasm doesn't seem worse than that (if you're concerned about its binary nature, there's a standard textual format).

There's no technical way to enforce that code is shipped to people in an easily readable/editable format: JS or wasm or machine code can all be equally difficult to consume. Enforcing this requires a human solution, and that is exactly why viral copyleft licenses exist (including the AGPL you reference).

No, unreadable, non-free JavaScript is not fundamentally different. Two wrongs don't make a right.

Unreadable, non-free JavaScript is used to reach a goal. That goal is to withhold the source from the users to bind them to the service. This leads to centralization, power imbalances, and thus attacks on the freedom and sovereignty of the users.

WebAssembly is a technology to achieve the formerly stated goal easier and more convenient. Of course, some people will be interested in that and work on it.

Mozilla is working on this. So far so good (or bad). The issue arises when you combine this fact with the self-portrait of Mozilla as the one defending the rights and freedom of the users.

> WebAssembly is a technology to achieve the formerly stated goal easier and more convenient.

WebAssembly is a technology to achieve better performance on the web, and that as a side-effect happens to achieve withholding the source easier.

Actually, it's pretty much like minifiers. And I guarantee you: the main reason most people are using minifiers is to improve performance, not to hide the source. That just happens to be a side effect.

What you call a "side-effect" can quickly turn into the main reason for using it.

Companies can develop big, bulky WASM-only framework with graphic primitives & so on, very much like Java applets, and effectively kill the openness of the web standards.

As an end-user there's no way to avoid loading hundreds of MB of WAMS every day, contrarily to desktop software installation.

the same is true about js really.

Sure, it can become the main reason for people to start using it. It's disingenuous to claim that that is Mozilla's goal, though.

(Apart from that I doubt that it will result in a significantly worse web than what we have today, but we'll see.)

wasm's true goal is to bring more performance and technology-independence to the web, which leads to more decentralization, user power, etc. For instance, more things can "run everywhere" because the performance is acceptable in a browser and so writing native applications for individual platforms isn't necessary. Moving things to the web becomes much easier because it is easy to retarget existing code in native languages without having to rewrite it all. And, importantly for freedom, those mean more things can be freely accessible webapps rather than having to go through the mobile vendors' stores and vetting.

All of these benefits come without a significant cost to user freedom because the cost has already been paid, and will always be paid no matter the underlying technology: companies will always ship obfuscated code if they feel that's important. (Also, I suspect most minification is driven by bandwidth and page speed concerns.)

Lastly, I don't think wasm is actually noticeably more convenient: shipping wasm requires a compilation step, just like minifying JS.

Since Wasm is one of the few virtual machines that are deterministic, it is very useful for distributed systems that need consensus. The way it uses types and external function calls is great for standardizing interfaces. It's also one of the few languages that can be reliably sandboxed. Contrary to Javascript, trust can be minimized.

I just hope that complex features such as multithreading or garbage collection don't become a mandatory component of the base VM. A complete, JITable-Implementation in RPython is now just about 3k LOC.

Go look at the output of the closure compiler (in advanced mode) and then tell me again how it gives the user a meaningful way to alter, read, improve or understand it.

Reply on news.ycombinator.com