Hacker News Reader

Comment by lmm | Hacker News Reader

> WASM vs a container runtime isn't a meaningful comparison because they're at different layers of the stack. A container runtime runs a process tree in a chroot, and whether the process binaries are native code (x86, ARM) or bytecode (JVM, WASM, CLR) is an implementation detail of the runtime.

It's a meaningful comparison because they often solve the same business problem; you need to run some code in an isolated/managed environment. Whether that's done through a process tree or a single process is an implementation detail for many purposes; not being able to run multiple processes might have implications for some use cases, but a lot of systems (e.g. docker/kubernetes, or especially anything serverless) are oriented around using a container for a single process.

View on HN

A comparison between WASM and x86/ARM/etc native binaries is meaningful, because those are different formats for executable code.

A comparison between WASM and "containers" is meaningless, because the binaries being executed by a container runtime could be written in WASM. The executable format and the packaging format are separate concerns.

This might be easier to think about if you imagine the article was written as "native code vs containers" -- what conclusions (if any) could you draw from the benchmarks in an article with that premise?

A comparison between WASM and "containers" is meaningful because in popular usage there's a cottage industry of WASM-based container solutions with the express goal (and co-evolved with the language to make this possible) of simplifying some of the thornier design decisions that make other containerization solutions easier to get started with (can just drop in any binary and dependencies) but also less performant for some set of tasks (have to set up network cgroups and other garbage). The phrase "WASM" isn't just being used to refer to the actual stack machine.

WASM is WebAssembly. Words have meanings.

If someone wants to try to advertise some weird custom platform that uses WASM as an intermediate bytecode for its packaging format then that's fine, but they'll need to pick a different name.

WASI is a part of the WASM charter, and parts of WASM are explicitly designed to be friendly to such ideas; It's not quite _just_ some choice of bytecode.

Besides, words are just approximations of thoughts, and even on the best of days the delineations aren't crisp. There's a critical mass of people using WASM+containers to refer to WASM ... plus containers (especially those built on the core tech supported by the WASM mission -- WASI -- like the platform tested in the article).

Your argument is nonsense. It's like arguing that comparing the performance of an API that use lambdas VS a traditional API with an application running in the server is meaningless because "the lambda could be written in the application server". Who cares? If both can be used to implement the same API, the comparison is meaningful.

Ok then. Let's say I write a webserver with WASI, compile it to a `.wasm` file, package it as an OCI container image, and deploy it in Kubernetes via a container runtime that loads the entry point into wasmtime.

If containers and WASM are in fact competing technologies, as you and the article imply, then this shouldn't be possible.

On the other hand, if WASM is a format for executable code as I claim, then packaging WASM as a container image and executing it in a container runtime is fine and should work as well as any other machine-independent bytecode (such as JVM).

WASM is a bytecode format like Java bytecode... the difference is that it's sandboxed. It can't do anything that's not explicitly given to it, including using WASI (the POSIX-like API for WASM code to "talk" to the system).

Because it's sandboxed, you can use it without a container. I think that's what you don't seem to undestand. There are several companies offering WASM-based "containers" in the cloud - which don't need any actual container, the WASM runtime has the same type of capability of a container, to isolate processes running on the same hardware securely.

It's even possible to make an actual Docker container run purely on a WASM runtime, as Docker itself is doing now! https://wasmlabs.dev/articles/docker-without-containers/

All bytecode is sandboxed by definition -- the VM decides which operations it delegates to the system. It is possible (and common!) to use JVM bytecode in a VM that restricts access to the underlying system, and in fact one of the original core use cases for Java (applets) relied on this functionality.

The difference between WASM and JVM is that WASM was designed to be both (1) a compilation target for memory-unsafe languages like C, and (2) have verifiable control flow so it's easier to write a provably-secure JIT.

  > Because it's sandboxed, you can use it without a container. I think
  > that's what you don't seem to undestand.

You don't seem to understand what a container is, or what a sandbox is.

The reason to deploy software as a container image (instead of a standalone binary) is that a container image contains a full chroot, including auxiliary files that aren't embedded into the main binary. Whether the binary is native machine code or WASM doesn't matter -- the tradeoffs of bundling everything into one binary vs placing them on disk are the same regardless of executable format.

The reason to run a sandbox is to restrict which system resources a process can access or interfere with. You can sandbox a process whether or not it runs in a container.

I see you like to ignore reality and go on with your own definitions for things.

> All bytecode is sandboxed by definition

Oh my... you probably mean "all bytecode COULD be sandboxed"... try sandoboxing JVM bytecode... they tried that for years :D didn't quite work.

> The reason to deploy software as a container image (instead of a standalone binary) is that a container image contains a full chroot,

No. Stop trying to tell us what a container should be used for. A container's main usage nowadays is to run multiple isolated "processes" or set of processes in a safe manner, making the most of the hardware... coincidentally, you can also do that using WASM. Get over your outdated worldview, mate.

EDIT: please read the link I provided. From the creators of Docker:

"If WASM+WASI existed in 2008, we wouldn't have needed to create Docker."

How does that align with your definition of what a container is or isn't?

As an aside, to what degree does WASI exist _now_? The spec seems to be in a state of flux as to what the language the spec is written in is, and the language new proposals are written in seems to have grown futures? On the other hand, as far as I can tell, the latest draft spec doesn't look to have support for UDP or scalable notification (epoll, kqueue, etc.), so is that really what people are using their existing software with?

Docker's great win is that you don't even need to recompile your software to use it, much less port it to what's essentially a new non-POSIX operating system.

  > As an aside, to what degree does WASI exist _now_?

It's ... rough. The impression I get (as an uninvolved third-party) is that the WASI folks set out with a goal of writing a sort of capability-based POSIX that they could write a thin libc for, but partway through realized that POSIX embeds a lot of assumptions that aren't compatible with portability or capability-based security.

IMO (again, no direct involvement) a better approach would be to start with a low-level API that is capability-based from the beginning. Something like EFI, or (more experimentally) an RPC-oriented syscall API resembling Fuchsia/Plan9. Then the various sorts of magic integers and process state found in POSIX can be layered on top of that as a library.

The good news is that the people working on WASI do seem aware of what they've gotten themselves into, and I think a lot of the chaos (shifting repos, broken docs, etc) is just the natural outcome of them exploring the solution space. My expectation is that they'll be forced to drift pretty far from POSIX if they want a workable design, but maybe they'll surprise us.

Yes, a lot is in flux. Just now I bumped into https://wasix.org which I have yet to figure out how it (will) fit(s).

> If containers and WASM are in fact competing technologies, as you and the article imply, then this shouldn't be possible.

That doesn't make any sense to me. Just because you can put a thing inside another thing doesn't mean they don't also solve an overlapping set of problems.

But they're not solving overlapping sets of problems. That's the point.

* WASM competes with native machine code (x86, ARM, etc) as the format of an executable binary.

* Container images compete with Apt, RPM, and tarballs as a packaging and configuration mechanism.

* Container runtimes compete with systemd as a way to manage process trees.

There is no overlap here.

Let's replace with food. Comparing eating soup with eating at a restaurant is meaningul because both are used to solve the same problem. Arguing that you can also eat soup at restaurant so these things are at different stack layers and should not be directly compared is a nonsense argument.

Reply on news.ycombinator.com