News for hackers. Stuff that matters.
Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Tuesday September 21, 2021 @07:13PM (#28611189)
At some point we need to stop inventing VMs. VMs like Java, .Net, etc, are already good enough. What is the point of yet another VM? The same people who designed web assembly could have taken java bytecode and added new APIs on top. Instead, they invented yet another machine encoding that has to be targeted, except this time we get to re-invent all the tooling.

Look... I hate the Java language with a burning passion, but the Java VM core technology is perfectly acceptable. So is .Net. There is no reason for webassembly, other than that mozilla wanted to invent something.

Re:Introduction to Hippo: The WebAssembly PaaS by tiew9Vii on Wednesday September 22, 2021 @02:07AM (#28613523)
The JVM does way more than Webassembly, completely different runtime characteristics. Webassembly is not attempting to be or do anything near what the JVM does.

Webassembly was designed for sandboxing untrusted code in a webbrowser, giving native like performance and limited functionality.

It just so happened the same characteristics for running untrusted code in the browser work really well for usecases people use AWS Lambda for etc. You have small lightweight applications that have limited system access you need to binpack and have fast startup / low overhead.

Webassembly/WASI isn't replacing the JVM/.NET, it's providing an alternative for specific use cases, running untrusted code in isolated environments that is fast and light weight.

Re:Introduction to Hippo: The WebAssembly PaaS by pjmlp on Wednesday September 22, 2021 @03:25AM (#28613881)
It is only going to be fast and light weight if we get stuck with MVP 1.0, supporting only C, C++ and Rust, with hacks for the remaining languages.

20 years ago I was running untrusted code in isolated environments via application containers like HP-UX Vault and later Java Application Servers.

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Wednesday September 22, 2021 @06:48PM (#28623037)
Exactly. Web assembly doesn't support basic features like tail calls (neither does java), which are vital for whole classes of languages. This is where silicon excels... at letting you actually implement languages in the best way, instead of forcing you to think in particular paradigms. I believe .NET/CLR supports tail call optimization (I think it must for F#).
Re:Introduction to Hippo: The WebAssembly PaaS by pjmlp on Thursday September 23, 2021 @02:51AM (#28625946)
F# came later into the game, CLR was designed as COM evolution and was supposed to be for VB, C#, J# (evolution from J++ and migration path to .NET), and C++ (initially Managed C++, the C++/CLI with .NET 2.0).

On top of that, Microsoft enganged with the language community so that there were about 20 other languages available for .NET 1.0 on release date.

Here, diggging through the archives,

https://docs.microsoft.com/en-us/archive/msdn-magazine/2002/...

> One of the exciting things in Visual Studio .NET is its language agnosticism. If a vendor has written a .NET-compliant language, you can use it in Visual Studio .NET. It'll work just as well as C# or C++ or Visual Basic. This isn't just a future feature-in-planning. There are already nearly two dozen languages being developed for Visual Studio .NET: Visual Basic, C#, C++, JScript, APL, Cobol, Eiffel, Fortran, Pascal, Perl, Python, RPG, Smalltalk, Oberon, Component Pascal, Haskell/Mondrian, Scheme, Mercury, Alice, and even the Java language.

Naturally MSIL had to support all of them.

The dynamic runtime came later as side effect from IronPython and IronRuby efforts.

Naturally WebAssembly folks are going to tell you they are the very first of this kind of efforts.

Re:Introduction to Hippo: The WebAssembly PaaS by infogulch on Tuesday September 21, 2021 @07:32PM (#28611350)
We're biased towards additive solutions [0], but sometimes subtraction is the right answer to a design problem. The problems that WA aims to solve from existing VMs like JVM/.NET are caused by the old APIs themselves, adding more API surface would not help.

[0]: Adding is favoured over subtracting in problem solving https://news.ycombinator.com/item?id=26727878

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Tuesday September 21, 2021 @10:15PM (#28612456)
Okay then define a subset of java opcodes supported and then modify the open source hotspot.

Look I'm trying to implement a wasm backend into an existing language right now and it could be a lot easier by either making wasm into a real architecture (with registers) or using an existing stack based vm isa.

Re:Introduction to Hippo: The WebAssembly PaaS by infogulch on Wednesday September 22, 2021 @01:27AM (#28613326)
WA can be transformed into native machine code in linear time, directly executed at (near) native speed, while retaining the VM memory protection barrier. No other VM can come close in these three properties at once.

If you're trying to integrate WA into a host language the easiest, fastest, and safest way would be to pick up one of the established well-polished compilers or interpreters and calling into it with a standard FFI interface.

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Wednesday September 22, 2021 @11:18AM (#28617335)
Firstly... Any stock vm isa can be linearly compiled if you give up certain optimization.

For example, if wa wanted to use a coloring allocator it wouldn't be linear time anymore. That's not a fundamental part of it, just an implenebtation choice.

Re:Introduction to Hippo: The WebAssembly PaaS by infogulch on Wednesday September 22, 2021 @12:57PM (#28618710)
Firefox's WA backend does streaming compilation (i.e. compiling bytecode directly to machine code while it's still coming off the wire) for Tier 1, right now, by default, today. Afaik, WA is the first mainstream vm isa that it's even possible to do this. Do you know of any other VM that can compile its bytecode in one pass that is on by default? I'm genuinely interested. https://wingolog.org/archives/2020/03/25/firefoxs-low-latenc...

But this whole discussion is out of scope for your use-case. If it's For Fun (tm) that's one thing, but (presumably) this is a practical integration into an existing language. Why are you implementing a VM instead of integrating an existing implementation? Certainly you wouldn't even consider implementing a custom from-scratch implementation of the JVM, the fact that it's even possible to attempt such a thing for WA is already telling about which VM has a better design.

Take your pick: https://github.com/appcypher/awesome-wasm-runtimes

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Wednesday September 22, 2021 @06:52PM (#28623073)
For some reason, it seems like you didn't read my comments. I'm not writing a WASM interpreter or JIT compiler... that would be quite straightforward. I'm attempting to implement a compiler backend for an existing programming language so that it can target WebAssembly. Since this is a functional language, it doesn't do things like have 'structured conditionals' (i.e., prodecural-like If/For/While statements and loops). Instead, it has recursion, which WebAssembly is terrible at. Not that other VMs are much better. You can make a claim this is about performance, but not in good faith. JMP is one instruction on X86_64 and B and friends on ARM are similar.

All these VMs and runtimes want to force you into particular ways of thinking about programming. This is terrible for the community. You can say Web Assembly is meant to be an open standard and you can sing that till the cows come home, but leaving out basic support for things like TCO, direct jumps, etc that are vital for compiling any non-procedural language, is just inexcusable at this point.

Re:Introduction to Hippo: The WebAssembly PaaS by UncleEntity on Tuesday September 21, 2021 @11:02PM (#28612699)
Couldn’t wasm be compiled down to either a stack or register based VM equally well?

The text version is basically an ast (with the binary form being a desugared version of that) so you could do whatever you want to transform into something executable.

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Thursday September 23, 2021 @12:57AM (#28625329)
No. WASM is fundamentally a stack machine. That's how its semantics are defined.
Re:Introduction to Hippo: The WebAssembly PaaS by sitkack on Thursday September 23, 2021 @02:35AM (#28625834)
It is a mechanical transformation from stack to registers. In other parts of the thread you mentioned TCO, one can also convert recursion into iteration, tail calls can be handled by the compiler or with a trampoline.

The universe is much more flexible than you give it credit for.

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Thursday September 23, 2021 @11:07AM (#28630256)
Recursion can be converted to iteration very easily but then you lose all benefits of web assembly (dynamic linking, for example(.

The conversion from recursion to iteration mandates that all recursive entry points be known ahead of time so you can build a loop/conditional tree. If you want to dynamically load code, this creates two tiers of languages on the runtime.

You really think I haven't thought of this?

Re:Introduction to Hippo: The WebAssembly PaaS by brundolf on Tuesday September 21, 2021 @09:01PM (#28611989)
Sometimes adding the right thing can give you the opportunity to subtract. Code running in WASM may not have to run inside a Docker container running inside a Linux VM.
Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Tuesday September 21, 2021 @11:34PM (#28612866)
Nothing needs to run Ina container Containers are just software engineerings latest name for a unix process. Both were designed to achieve similar levels of isolation.

In reality,there's no such thing as a container. As far as Linux is concerned, containers are just processes with attributes, because that's what they are, we just decided to complicate it a lot

Re:Introduction to Hippo: The WebAssembly PaaS by pjmlp on Wednesday September 22, 2021 @02:00AM (#28613478)
Just wait until WebAssembly actually moves beyond the MVP, which is stuck at.
Re:Introduction to Hippo: The WebAssembly PaaS by unrealhoang on Tuesday September 21, 2021 @08:25PM (#28611747)
I know right, everyone wants to make their own VM become "the one" for computing to collect the sweet sweet tax.

If only the major companies sit together and agree upon a standard and let multiple VM implementations compete in an open-source manner ... oh wait, that's wasm.

Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Tuesday September 21, 2021 @10:16PM (#28612459)
.net is an open ieee standard with several implementations. Java is too at this point

Both are more advanced

Re:Introduction to Hippo: The WebAssembly PaaS by mftb on Wednesday September 22, 2021 @02:44AM (#28613689)
This, "...other than that mozilla wanted to invent something." Is not what happened. The browser vendors; Apple, MS, Google and Mozilla, whatever their reasons, decided they were going to kill Java and Flash in the browser. They then flailed about with NACL and other things, before Mozilla put forward WASM and they again, for whatever their reasons, accepted it. Complaining about it now, at least a decade late, is just weird to me. WASM isn't of interest because it's another VM, it's because it's the only VM that runs in the browsers (and soon lots of other places).
Re:Introduction to Hippo: The WebAssembly PaaS by iammisc on Wednesday September 22, 2021 @06:53PM (#28623086)
I understand that. I'm not saying WASM isn't of interest. On the contrary, since I'm currently implementing language support for WASM, I'd say it's very important.

What I am saying is that it is Java VM 2.0. The java ISA was perfectly fine. People knew how it worked, there was lots of tooling, etc. Instead of building off that, they made something new... just because. WASM is technically inferior to java, and is based upon the same basic principles. It's just like java bytecode in the 90s. It's not even done yet. This is a terrible mess.