WASM will replace containers

WASM will replace containers(creston.blog)

325 points by hpincket 1 year ago | 356 comments

not2b 1 year ago |

"The main thing holding back wider adoption is a lack of system interfaces. File access, networking, etc. But it's just a matter of time before these features get integrated."

But then you've got to figure out and prevent all the security holes that can be introduced by adding file access, networking, etc. That's what killed the Java write-once, run-anywhere promise. Maybe put the whole thing into a container? Oops, looks like the container wasn't replaced after all (though perhaps it could be simplified).

josephg 1 year ago | |

True, but I suspect it'll be a lot easier to virtualise all those APIs through WASM than it is for a regular native binary. I mean, half the point of docker is that all syscalls are routed into an LXD container with its own filesystem and network. It should be pretty easy to do the same thing in userland with a wasm runtime.

And the nice thing about that is you can pick which environment a wasm bundle runs in. Want to run it on the browser? Sure! Want to give it r/w access to some particular path? Fine! Or you want to run it "natively", with full access to the host operating system? That can work too!

We just ("just") need wasi, and a good set of implementations which support all the different kinds of sandboxing that people want, and allow wasm containers to talk to each other in all the desirable ways. Make no mistake - this is a serious amount of work. But it looks like a very solvable problem.

I think the bigger adoption problem will be all the performance you leave on the table by using wasm instead of native code. For all its flaws, docker on linux runs native binaries at native speed. I suspect big companies running big cloud deployments will stick with docker because it runs code faster.

quesomaster9000 1 year ago | | |

As somebody who's in the process of building a sandbox for RISC-V 64 Linux ELF executables, even I'm still on the fence.

The problem is that in WASM-land we're heading towards WASI and WAT components, which is similar to the .NET, COM & IDL ecosystems. While this is actually really cool in terms of component and interface discovery, the downside is that it means you have to re-invent the world to work with this flavor of runtime.

Meaning... no, I can't really just output WASM from Go or Rust and it'll work, there's more to it, much more to it.

With a RISC-V userland emulator I could compile that to WASM to run normal binaries in the browser, and provide a sandboxed syscall interface (or even just pass-through the syscalls to the host, like qemu-user does when running natively). Meaning I have high compatibility with most of the Linux userland within a few weeks of development effort.

But yes, threads, forking, sockets, lots of edge cases - it's difficult to provide a minimal spoof of a Linux userland that's convincing enough that you can do interesting enough things, but surprisingly it's not too difficult - and with that you get Go, Rust, Zig, C++, C, D etc. and all the native tooling that you'd expect (e.g. it's quite easy to write a gdbserver compatible interface, but ... you usually don't need it, as you can just run & debug locally then cross-compile).

danpalmer 1 year ago | | |

This assumes that everyone implements the same set of APIs that work in the same way.

More likely, the browser will implement some that make sense there, some browsers will implement more than others, Cloudflare workers will implement a different set, AWS Lambda will implement a different set or have some that don't work the same way... and now you need to write your WASM code to deal with these differing implementations.

Unless the API layer is, essentially, a Linux OS or maybe POSIX(?) for Docker, which I doubt it would be as that's a completely different level of abstraction to WASM, I don't have a lot of faith in this being a utopian ideal common API, given that as an industry we've so far failed almost every opportunity to make those common APIs.

yencabulator 1 year ago | | |

> half the point of docker is that all syscalls are routed into an LXD container with its own filesystem and network. It should be pretty easy to do the same thing in userland with a wasm runtime.

This is a serious misunderstanding of how containers work.

Containers make syscalls. The Linux kernel serves them. Linux kernel has features that let one put userspace processes in namespaces where they don't see everything. There is no "routing". There is no "its own filesystem and network", just a namespace where only some of the host filesystems and networks are visible. There is no second implementation of the syscalls in that scenario.

For WASM, someone has to implement the server-side "file I/O over WASI", "network I/O over WASI", and so on. And those APIs are likely going to be somewhat different looking than Linux syscalls, because the whole point is WASM was sandboxing.

Quite far from "pretty easy".

funcDropShadow 1 year ago | | |

> True, but I suspect it'll be a lot easier to virtualise all those APIs through WASM than it is for a regular native binary. I mean, half the point of docker is that all syscalls are routed into an LXD container with its own filesystem and network. It should be pretty easy to do the same thing in userland with a wasm runtime.

All of this sounds too good to be true. The JVM tried to use one abstraction to abstract different processor ISAs, different operating systems, and a security boundary. The security boundary failed completely. As far as I understand WASM is choosing a different approach here, good. The abstraction over operating systems was a partial failure. It succeeded good enough for many types of server applications, but it was never good enough for desktop applications and system software. The abstraction over CPU was and is a big success, I'd say.

What exactly makes you think it is easier with WASM as a CPU abstraction to do all the rest again? Even when thinking about so diverse use-cases like in-browser apps and long running servers.

A big downside of all these super powerful abstraction layer is reaction to upstream changes. What happens when Linux introduces a next generation network API that has no counterpart in Windows or in the browser. What happens if the next language runtime wants to implement low-latency GC? Azul first designed a custom CPU and later changed the Linux API for memory management to make that possible for their JVM.

All in all the track record of attempts to build the one true solution for all our problems is quite bad. Some of these attempt discovered niches in which they are a very good fit, like the JVM and others are a curiosity of history.

SEJeff 1 year ago | | |

docker and lxd are competing projects. Docker does not use lxd to launch containers. lxd was written by the lead dev (at canonical) of lxc which was not as polished as docker but sort of kind of did the same thing (ran better chroots)

They both use Linux kernel features such as control groups and namespaces. When put together this is referred to as a container but the kernel has zero concept of “a container”.

guappa 1 year ago | | |

> It should be pretty easy to do the same thing in userland with a wasm runtime.

Not easy and certainly not fast.

v3ss0n 1 year ago | | |

When did docker started using LXD ? i never knew.

resonious 1 year ago | |

This is what I was thinking. WASM is a good replacement for containers because it doesn't have these things.

gchamonlive 1 year ago | | |

So basically virtual machines, those we can spin up with lxd or firecracker. Not that they don't have file access, it's just that's finnicky compared to containers (I'm thinking docker/podman)

Capricorn2481 1 year ago | | |

I don't understand WASM, but I read that a big draw of WASM is it's ability to provide portability to any language. This would mean Python libraries that depend on an unpopular C library (which could be lost to time) could instead be a single WASM blob.

Assuming equivalent performance, which I understand might not be the case, is there merit to this idea? Or is there nothing new WASM provides?

afiori 1 year ago | | |

The idea with wasi containers is that you could spin up a container with only the interfaces it needs.

paul_h 1 year ago | |

Java's SecurityManager was cool at the start, but over the years there was a steady series of ways to side step it. And now Oracle are wholly deleting it in JDK 25 - https://openjdk.org/jeps/486. It was a stand out feature IMO, and I'll miss it.

throwaway7783 1 year ago | |

You meant Java applets perhaps? Java is still write-once run-anywhere if you stick with its APIs.

rr808 1 year ago | |

ActiveX had this sorted out 25 years ago. Code signing with different levels available for access outside the sandbox controllable by the user.

lxgr 1 year ago | | |

And a nice centralized authority that judges the trustworthiness of a given application by staring at a binary extensively?

okeuro49 1 year ago | |

> That's what killed the Java write-once, run-anywhere promise.

I write Java software on Intel and deploy to an arm device.

The promise seems to work for me.

account42 1 year ago | | |

Cross compilers have solved this use case for pretty much any language with enough demand.

Meanwhile you won't have much luck running Eclipse or any other large Java program on your custom OS or hardware platform if you just port the JRE.

yencabulator 1 year ago | | |

That's run-on-the-other-device-I-manage, not run-anywhere. Run-anywhere was used in the meaning of run-by-untrusting-parties, like javascript on the web.

rollcat 1 year ago | |

> But then you've got to figure out and prevent all the security holes that can be introduced by adding file access, networking, etc. [...] Maybe put the whole thing into a container?

Since this is an emerging ecosystem, why not take a different spin on security, and instead try e.g. capabilities? Instead of opening a connection to the DB, or a listening socket, you get FDs from your runtime. Instead of a path where you can read/write files, such as assets or local cache, you get a directory FD from openat (not sure right now if that could be bypassed with "..", but you get the idea).

Bonus: you can get hot code reloading for very cheap.

lmm 1 year ago | |

Java write once run anywhere is fine. Java people don't generally bother with containers because there's no point, the JVM already solves the same problem.

bzzzt 1 year ago | | |

Almost all modern Java frameworks specifically target Docker containers in the cloud.

afiori 1 year ago | | |

Portability and sandboxing are two very different properties.

BrouteMinou 1 year ago | |

I think you meant Java Applets instead of Compile once run everywhere.

mrkeen 1 year ago | | |

Right, now it's compile once, don't run on the web.

7e 1 year ago | |

Even containers aren’t really secure. You need a VM boundary.

dathinab 1 year ago | |

> That's what killed the Java

It's a similar but quite different solution.

Java

- was designed with a lot of tight system integration foremost, sand boxing being secondary

- a ton of the sandbox enforcement where checks run in the same VM/code as the code they where supposed to sandbox, like you Java byte code decided if Java byte code should be able to access file IO etc.

- Java Applets are, at lest for somewhat more modern standard, a complete security nightmare _in their fundamental design_, not just practically due to a long history of failure.

- a lot of the security design was Java focused, but the bytecode wasn't limited to only representing possible Java code

- Java "sandboxing" targeted a very different use-case/context the "WASM replace containers" blog is speaking about, mainly the blog is about (maybe micro-) servies while Java sandboxing was a lot about desktop application. I.e. more comparable with flatpack and their sandboxing is also (sadly) more about compatibility then security (snap does that better, but has other issues).

And especially the last point one is one to really important as we are not speaking about WASM replacing sandboxing e.g. for dev tools and similar but sandboxing for deployment of micro services written with it in mind. In such context

1. you (should))always run semi trusted code, not untrusted code

2. when giving access to other resources (e.g. file system) it's often in a context where you normally don't need any form of dynamic access management (like you need on a desktop) which means _all the tech underlying to containers can be used with WASI_. Like there is no reason not to still use cgroups, dropping privileges and co integrated in your WASI VM in the same way docker and co uses them.

3. (I kinda thing) there is a (subtle/very slow) trend to not rely only on container isolation but e.g. have a firecracker micro vm run multiple closely coupled containers (a pod/side care container) but place not closely coupled containers in different micro VMs.

The true challenge isn't WASI, but that it's competing with docker->kubernets where docker is "one thing fit's all (badly)" solution which can not only run your services but can also run all kind of dev tooling, legacy applications etc. without requiring any changes to them and can (badly but often good enough) simulate your deployment locally with compose. Then to make the competition hard kubernets has been become somewhat of a "standard" interface to deployment, especially in the cloud, this might suck, but also mean you use OIC images both locally in in production. And that is what the WASI for service sandboxing use-case is competing with OIC images and software running them, nut just docker.

yencabulator 1 year ago | | |

> Java

> - was designed with a lot of tight system integration foremost, sand boxing being secondary

> Java sandboxing was a lot about desktop application

I think this is a false history. Java was designed for interactive television. As in cable television set top boxes receiving apps broadcast over the cable and executing them.

guappa 1 year ago | |

I don't think it was killed by security, since nobody cares about security. At most companies care about pretending to do security.

Dalewyn 1 year ago | |

>But then you've got to figure out and prevent all the security holes that can be introduced by adding file access, networking, etc.

So an operating system?

cookiengineer 1 year ago | | |

Yes and No.

Check out the WASI repository. For people not understanding what WASI is, I always tell them it's something like a reference/specification of cross platform syscalls that have to be implemented in WASM VMs.

Of course, access to such things always come with assumptions of control and policies that rely on behavioral analysis. So I hope that something similar to host and web application firewall rules will come out of this, similar to how deno does it.

[1] https://github.com/WebAssembly/WASI

klabb3 1 year ago | | |

Yes. Wasm does to my knowledge not have an answer for this, even if some projects patch in their bridge logics. Networking and file systems, and the permission model, is "the rest of the fucking owl". Linux isn't standardized, but at least it's Linux. Without consensus on the fundamental APIs I don't see how we can get to a platform agnostic experience. Even an https call isn't simple: you need TCP and you need to pull root certs from the env, at the very least. Where's the API for that?

I hope for a much more near term bright future for WASM: language interop. The lowest common denominator today is C, and doing FFI manually is stone age. If you can leverage WASM for the FFI boundary, perhaps we can build cross language applications that can enjoy the strengths of all libraries, not just those outside of our language silos.

danpalmer 1 year ago |

WASM solves a different problem to containers. Where WASM does well is in running sandboxed code efficiently, because that's where it started out. I think WASM will likely take over as the standard for shipping things like Functions-as-a-Service implementations, and other forms of plugins, where one host application/server of some kind wants to efficiently run pieces of untrusted logic.

Containers don't solve that problem. They aren't a particularly good security boundary, and they are much heavier weight, in terms of bytes and startup costs, than WASM binaries, because they are deeply integrated into the OS for networking, etc. However, when what you need to do is ship a binary with a bunch of accoutrements, dependencies, files, etc, and then run multiple processes, multiple threads, and use more of the OS primitives, containers are an ergonomic way to do that, and that suits Infrastructure-as-a-Service much more closely.

paulgb 1 year ago |

> WebAssembly is a true write-once-run-anywhere experience. (Anywhere that can spin up a V8 engine, which is a lot of places these days.)

This is true if your wasm code is purely computational, but if it interacts with the outside world it’s a different story. Each V8 runtime has a subtly different interface, so code that runs on cloudflare V8 might not run in Bun or Deno. Not to mention if you want to support WASI too, which is a different set of bindings even though it’s still WebAssembly.

Love or hate Docker, part of its success was that POSIX was already a fairly established standard and there weren’t a lot of vendors driving it in different directions.

porridgeraisin 1 year ago | |

> Bun

Nit: bun uses javascriptcore

stackskipton 1 year ago |

As PlatformOps (formerly DevOps (formerly SRE (formerly Ops))), either this was hilarious satire or ChatGPT Ketamine trip. I'm not sure.

> In the year 2030, no one will remember Kubernetes.

So what's going to handle out rolling out new versions of your WASM, setting up whatever Reverse Proxy you pick and other stuff involved getting. A bunch of scripts you wrote to do this for you? https://www.macchaffee.com/blog/2024/you-have-built-a-kubern...

> The promise of DevOps has been eroded by complicated tooling and tight coupling of program-container-linux. In my experience, developers want to write code and ship features to hit their quarterly goals.

Here is why we ended up here: In my experience, developers want to write code and ship features to hit their quarterly goals.

Sure, and my angry PlatformOps (formerly DevOps (formerly SRE (formerly Ops))) is stuck picking up the pieces because we are getting crap while we desperately paging you because we have no clue what "duplicate street key" in your logs mean. On top of that, InfoSec dropped us 10 tickets about code level library vulnerabilities in your docker container but all the Developer's Managers got together to convince them it was our problem somehow.

So we are forced to write this bundle of terribly written Ops type software in attempt to keep this train on the tracks while you strap rockets to cafe car.

WASM replacing containers is just a solution looking for a problem. Containers solved a problem of "How do we run two different versions of PHP on a single server without them colliding." Most of the containers problem is higher level DevOps problems that we haven't been able to solve and WASM isn't going to change that. I deal with a team that writes 100% Golang so their code is like WASM as it's ship binary and done. Yea, they begged for Kubernetes because it works a ton better then custom Ansible they wrote to keep these VMs/Load Balancer in sync.

hardwaregeek 1 year ago |

When? We’ve been talking about wasm for years. When are we actually getting this future? It’s been 8 years since wasm 1.0, and still we don’t have a stable, easy to use toolchain. Rust has maybe the best support and I still can’t get a basic async application with tokio to work on wasm.

To put it into context, Rust was released in 2012. 8 years later it was stable, had a solid toolchain and plenty of people using it in production. Wasm still feels like a toy compared to that

moribvndvs 1 year ago |

One benefit of being an old engineer is watching how excited people get when they rediscover something that has gone around the bend over and over again. I swear if you fuckers reinvent DCOM I will shit in your hats.

invalidname 1 year ago | |

Exactly. It's like the JVM circa 2004. Without all the observability and features we have today and half the performance/reliability/security.

pjmlp 1 year ago | | |

We had them, Java EE application servers had all of that available, as did CLR/IIS, or IBM AS/400 for that matter, really we have seen it before.

cheesekunator 1 year ago | |

I actually didn't mind COM and DCOM. I didn't overuse it, so it never bit me. I guess it's why I love using Microsoft Orleans. The virtual actor model is enough for me to solve almost every problem. If Cloudflare Durable Objects (https://developers.cloudflare.com/durable-objects) can reduce latency they might have the winning product.

crabmusket 1 year ago | | |

On that note, do you mind helping me understand something I haven't been able to glean from Microsoft's docs? Does Orleans give you a way to globally address a thread?

With Durable Objects, two clients on either side of the world can both request a websocket connection to an object with the same unique identifier, and all the bytes from those clients will land in one single process somewhere inside a CloudFlare data centre.

I am pretty sure the answer is yes, but the docs seem a bit less direct than CloudFlare's web focused use cases.

pjmlp 1 year ago | |

Actually it is more like CORBA, powered by RMI.

aqueueaqueue 1 year ago | |

I can invent spinning green balls.

RantyDave 1 year ago | |

OMG I hated DCOM so thoroughly.

mdaniel 1 year ago | |

Preach it, because document/literal SOAP and WSDL are The Way, The Truth, and The Light!

birdiesanders 1 year ago |

The author has not seemingly considered the vastly different networking in wasm. You don’t have networking. There is an entirely different utility in these environments, containers are meant to host applications, wasm is an application. Don’t even get me started on disk access, env handling, etc. wasi is great, for the places it does well. It is not a replacement for writing a pure golang/rust/c/julia app and running it in a container, it doesn’t have the facilities for that task.

mavdi 1 year ago | |

Anyone comes up with any shit these days, say apples will replace oranges.

“ChatGPT make me sound confident”

LeFantome 1 year ago |

WASM does not run on real hardware. At best, WASM can be considered a virtual machine (in the way that the JVM and the .NET CLR are virtual machines). I guess we can call that a "runtime".

Containers package applications that run directly on real hardware (well, directly on a real kernel that is running on real hardware). There is no runtime. I am talking OCI containers here (Docker and Kubernetes). At least they can. Most containers are probably running on a Linux kernel that is running in a virtual machine (in the way that KVM, EC2, and VirtualBox are virtual machines).

WASM needs a runtime. That is, it is going to run inside an application. That application needs to run on a kernel. So, WASM will always be further from the hardware than a container is.

WASM solves the same "portability" problem that the JVM and .NET do. So, maybe WASM wins against those environments.

That is not the problem that containers solve though. Containers bundle applications with their dependencies. They replace "installation and configuration" with instantiation (deployment). WASM does not magically eliminate dependencies or the differences between environments (not even the difference between V8 implementations).

If anything, the technologies are complementary. Maybe, in the future, all our containers will be runing WASM applications.

Or maybe we will run a different kind of container that ONLY runs WASM applications and then WASM can replace the Linux kernel running in a VM that hosts all our OCI containers today. Perhaps that is what the author really envisions. Even then, it sounds like more of a complement than a true alternative.

lxgr 1 year ago | |

WASM needs an execution environment just like containers. The execution environment for containers just happens to be largely provided by Linux.

> WASM does not magically eliminate dependencies or the differences between environments (not even the difference between V8 implementations).

Not by itself, and not currently, but I don't find it too much of a leap of faith to assume that that'll be standardized before too long.

invalidname 1 year ago | |

Yes. It doesn't provide the roughly 20 years of advancements in JVM technology either. Modern observability and JVM scale is at a different level. The trend was to get the maximum use of hardware. Specifically get away from virtualization to containers. This bucks the trend for absolutely no tangible benefit.

Thaxll 1 year ago |

"Learning how to use Docker is a distraction"

As if you need to learn anything, you get your Dockerfile and that's it, what else there is to learn? Your WASM app still need Kubernetes to run so it's not adding any value.

The complexity is not in running your app in Docker, the complexity is running your container somewhere, and WASM does not help at all with that.

WebAssembly is not going anywhere, it's pretty clear it won't grow much in the next 5years.

TZubiri 1 year ago | |

Disagree.

It's not trivial to manage a running container or group of, with firewalls and filesystems and whatnot.

My biggest gripe is that it's quite redundant with the os and tends to reinvent stuff. You end up needing to learn, doc, and build towards both os layer fw and container layer fw for example.

milesrout 1 year ago | | |

WASM will be that but tenfold surely? You would need to program against a completely new interface.

trescenzi 1 year ago |

Containers have two goals: reproducibility/portability, and encapsulation. WASM could replace the reproducibility but it can't replace the encapsulation.

> My money is on WebAssembly (WASM) to replace containers. It already has in some places. WebAssembly is a true write-once-run-anywhere experience. (Anywhere that can spin up a V8 engine, which is a lot of places these days.)

Luckily a container is a place that can spin up a V8 engine. If you want to bet on WASM my bet would be on containers running WASM.

jagged-chisel 1 year ago | |

> … it can't replace the encapsulation.

Can you explain your thoughts here? WebAssembly is sandboxed and effort must be expended to provide a mechanism for getting data through that boundary. How does that differ from “encapsulation?”

trescenzi 1 year ago | | |

I'm referring to a different kind of encapsulation. Dependencies, tools, version management, configurations, environment variables, etc. Even if you can fully compile your code into WASM and host it on V8 you need to ship it with configuration files, set specific environment variables and so on. Containers allow you to bundle all of that together into a single unit you can share with others.

bocahtie 1 year ago |

I'm always reminded of Gary Bernhardt's "the birth and death of javascript" when wasm gets discussed. While it's a bit tongue-in-cheek, I think it really drives home that it's really just another layer of abstraction that may or may not be useful for a given problem, and might not be the silver bullet that anyone is looking for. I recon that whether or not wasm will take over everything will mostly be about trade offs between it and the other solutions.

josh11b 1 year ago | |

That is what I was thinking of too! From 2014: https://www.destroyallsoftware.com/talks/the-birth-and-death....

tantalor 1 year ago | | |

Yes! I was trying to search for this but I couldn't remember the name.

afiori 1 year ago | |

This for sure, eg it will never be commonplace to run posgres compiled to wasm.

Most instances of "X will eat the world" and "X will be used anywhere" will be false even for very successful technologies

remram 1 year ago |

WASM might replace processes, but the idea that people will take the stuff they can't manage to put in a native process, and somehow manage to cram it into WASM... ridiculous.

There's not even a single argument in there to support the clickbait title. We have containers, but "containers are annoying". WASM won't be annoying? Pray tell, how do you surmise that?

Docker too complicated? Build times too long? You believe WASM tools will be simpler and faster... why?

kryptiskt 1 year ago |

In practice the problem containers solve is to bundle an application with its environment so that it will work the same on the developers machine and in production and in five years time when the servers are replaced with new ones running another distro.

The WASM world doesn't have most of the pieces of that puzzle and WASM itself is quite irrelevant. Say we standardized on a sandbox running x86_64 VMs under Firecracker, with the proper sandboxing that would work just as well as running WASM. You might say that WASM is portable, x86_64 assembler is not, to that I would counter that ARM (and probably RISC-V too) can emulate x86_64 faster than they can run WASM. So what's the point of the WASM piece of the puzzle?

aartav 1 year ago |

"The main thing holding back wider adoption is a lack of system interfaces. File access, networking, etc. But it's just a matter of time before these features get integrated."

Funny. The most obvious place for WASM is a web browser and yet WASM STILL cannot access the browser DOM. Its only been, what? At least 8 years of promises about it coming soon and how people are working on it.

diggan 1 year ago | |

Who exactly has promised it's "coming soon"? People like to make arguments against imaginary arguments for some reason.

Besides, you can already send data from/to Browser<>WASM context which seems to at least solve most use cases people was imagining for WebAssembly back when it was just asm.js.

ninetyninenine 1 year ago |

You underestimate developers.

WASM will never replace containers. People will be running wasm inside of containers. That's what will happen.

aftbit 1 year ago | |

Containers will never replace VMs either. People will be running WASM inside of containers inside of VMs.

timeflex 1 year ago | | |

Absolutely they will & do. The kernel provides the necessary sandboxing & is faster, even with things like Firecracker.

ninetyninenine 1 year ago | | |

Where did this extra VM come from?

deathanatos 1 year ago | |

Oh, I have seen this proposed, in real life. It was like 2019 or 2020, so not even new. Honestly, it was a good idea as it was proposed then, and I wish more of the tooling I interacted with adopt it.

WASM to an API is essentially the `Fn(…) -> …` type. E.g., you have

  POST /some/api

And it can take JSON, but what if it needs to do "something", where something depends on the consumer?

And across the board, what APIs/aaS's do is that some PM goes "I think these are the only 2 things anyone will ever want", those get implemented, and you get an enum in the API, the UI, the service, etc. And that's all it is ever capable of, until someone at the company envisions something bigger.

If I could pass WASM, I could just substitute my own logic.

Like webhooks, but I don't have to spin up a whole friggin' HTTP server.

hardwaresofton 1 year ago | |

WASM can, but does not replace containers. What is different is that instead of 20 applications running in 20 containers, 1000 applications will comfortably fit in one container, with better sandboxing than the linux process model at the application level.

timeflex 1 year ago | | |

I really wish you knew how silly this sounds & is. Why would you even run 1 container for 1000 applications if you're saying that WASM provides better sandboxing? Why wouldn't you just run a single WASM process? Also, containers are generally meant for single processes to provide isolation for each app, not to have all your apps running together with the same access.

What many people don't get between WASM & containers is that containers don't need software developers to make changes to support containers. WASM however relies on software developers to make changes to their apps. Otherwise, you have to emulate an entire architecture in WASM which doesn't perform well. It is the difference between VMs, which emulates physical hardware & containers which doesn't need to emulate the hardware cause it provides the sandboxing using kernel features.

ianburrell 1 year ago |

One advantage of containers is that run lots of software with it. Take old Perl application, wrap it in container, and then run in the cloud. Keep that old binary application that somehow lost the source for.

Also, I think most uses of containers lose the advantage of WASM. WASM is about running on any platform, great for browsers and serverless. But containers are usually run in controlled environment where can compile once and not pay the penalty of compiling each time.

andrew_rfc 1 year ago | |

Speaking of Perl: https://news.ycombinator.com/item?id=43017739

tombert 1 year ago |

It would be so great if WASM gives us the paradise that Java promised thirty years ago. Being able to get fast, "write once, run anywhere" would be awesome.

I wonder if someone could make a decent cross-platform GUI toolkit to save us from the horribly slow Electron-hell we've carved out for ourselves.

krackers 1 year ago |

https://www.destroyallsoftware.com/talks/the-birth-and-death...

udev4096 1 year ago |

Containers are not going away anytime soon. I feel like this is nothing but a clickbait post. There are crazy amounts of innovations happening in the CNI space, such as bootc, katacontainers, etc. Hundreds of CNCF projects (envoy and istio just from top of my mind) are being used world wide which mostly have built upon k8s. Why do you think they would stop to use an immature runtime whose goal isn't even the same as containers?

algorithmsRcool 1 year ago |

I just don't see it. WASM requires throwing away all the decades of x86/ARM compiler work in ecosystems like Java, .NET and C++ and placing all trust in the WASM runtime/V8 to perform as well as them.

zfg 1 year ago | |

It's doesn't. It's just another compilation target along side x86 and ARM and friends.

algorithmsRcool 1 year ago | | |

Yes, but now you are going through another translation (aka V8) layer in order to get down to x86 or ARM. You just have to hope that the optimizer of this translation layer is at least as smart as what you had before.

c0balt 1 year ago |

> In the year 2030, no one will remember Kubernetes.

As a sys admin, no, we will have to remember. Once a system is in place and "functions", they tend to stay for a long time.

aitchnyu 1 year ago | |

I believe at least one consulting company in this Indian city is still training new graduates in COBOL and setting them up with dead end careers.

pjmlp 1 year ago | | |

COBOL just had a new release, COBOL 2023 is the most recent standard.

Also does objects nowadays.

Additionally, given all the AI prompts being used nowadays writing long English texts instead of proper programming, COBOL was actually a language ahead of its time.

kortex 1 year ago |

It really won't. For some use-cases, yes.

> WebAssembly is a true write-once-run-anywhere experience.

Except not. The wasm ISA is really quite limited in the types of operations. A full-blown RISC/CISC ISA will have way more opportunities for optimization. To say nothing of multithreading and pipelining. JITing also has overhead.

> You can compile several languages into WebAssembly already.

But if you can compile them, why not just compile to container, and get free performance?

Wasm will have a hard time with anything low level: networking, I/O, GPU, multimedia codecs.

sleepy_keita 1 year ago |

I actually tried doing this a couple weeks ago. Rust on Cloudflare Workers. It didn't go well -- compiling to wasm disables a lot of Rust features, to the point where it just didn't make sense anymore. I gave up after trying to get some crypto stuff working. I eventually switched to using raw JS because Cloudflare Workers exposes the Web Crypto API, but next time I want to run Rust serverlessly, I'm just going to put it on Lambda, compiled to a regular binary.

syrusakbary 1 year ago |

The article is completely on point.

Personally, I don't think that Cloudflare is the best provider for Wasm at the Edge as everything needs to go through a Javascript layer that eventually hurts performance and prevents further optimization, but is a strong one nontheless (note: take everything with a grain of salt, even though I try hard to not be biased, I'm also founder of Wasmer)

> "The main thing holding back wider adoption is a lack of system interfaces. File access, networking, etc. But it's just a matter of time before these features get integrated."

Wasmer launched WASIX [1] a few years ago which fulfills the vision that the article describes. With WASIX you can have sandboxed access to:

  1. Filesystem
  2. Networking / Sockets
  3. Processes
  4. Threads

[1] https://wasix.org/

chambers 1 year ago |

I found WASM slower than expected. I wrote some WASM logic functions recently which I thought would perform better than their native JS equivalent. For example, take a large array and "pivot" it in 10ms instead of a 100ms.

What I found was the JS version was a bit faster than the compiled WAT. Yikes.

EDIT: I think I'll try debugging it more

ridiculous_fish 1 year ago | |

At $WORK we use SQLite in WASM via the official ES module, running read-only in browser.

The performance is very poor, perhaps 100x worse than native. It's bad enough that we only use SQLite for trivial queries. All joins, sorting, etc. are done in JavaScript.

Profiling shows the slowdown is in the JS <-> WASM interop. This is exacerbated by the one-row-at-a-time "cursor" API in SQLite, which means at least one FFI round-trip for each row.

chambers 1 year ago | | |

Yup, I've tested and seen WASM SQlite's slowness myself. But I don't think it's a SQLite problem per se.

I heard WebSQL, which used SQLite, was at least 10x faster than WASM SQLite. Probably even more.

fancyswimtime 1 year ago | |

the answer will be; depends what ur doing. There is a cost communicating with a worker

bayindirh 1 year ago |

This blog post's promise is all "pink fluffy unicorns", but for a single use case: "Long running containers powering microservices, probably in bigger installations, for consumer facing applications and APIs".

Containers are much more than that. They're service providers for small installations, short-running VeryFatBinaries, close to the metal, yet isolated complex applications in HPC environments.

WASM will be all and well, it'll be a glorified CGI, and might be a good one at that, we'll see, but it'll not and can't snipe containers with one clean headshot and be done with that.

It'll replace Kubernetes? Don't be silly. Not everyone is running K8S for the same reason, and I'm telling that as a person who doesn't like K8S.

gigel82 1 year ago |

No it won't. People primarily deploy containers for full fat native server applications containing tons of proprietary code and libraries and sometimes specialized hardware access (GPU, etc.).

It would be immensely silly to run full x86 emulators in WebAssembly and go through 2 layers of transpiling / interpreting for what can run natively on the host's CPU.

This argument always reminds me of "Square Hole!" video: https://www.youtube.com/watch?v=6pDH66X3ClA (just because you can make it fit, it doesn't mean you should do it).

tbrownaw 1 year ago |

> In the year 2030, no one will remember Kubernetes.

That's 5 years from now.

Which is a pretty good time frame for getting enterprisey things on to kubernetes.

And maybe a bit short for getting vendors to add a new sandboxed VM type to their supported platforms.

colonial 1 year ago |

Are WASM and containers not fundamentally different things?

At their heart, modern containers are a clever way to create something that looks like a Linux VM without the overhead of actual virtualization. Your application still executes "natively," just inside of a Potemkin environment (modulo whatever holes you poke in the veneer.) The latter bit is why we use containers.

WASM is a bytecode format. It doesn't carry around the environment it needs to execute correctly like a container does. In fact, it (by definition) needs an environment with certain properties (interpreter/JIT present) to work!

jb_gericke 1 year ago |

WASM solves a very different problem to Kubernetes, and you can happily run, scale and orchestrate WASM binaries on Kube.

fngjdflmdflg 1 year ago |

This post is really puzzling. How do I use libraries with WASM? Lets say I wrote a nodejs app, seemingly I will need to bundle not just node_modules but also the entire nodejs runtime to make it run. Why would I do this? How does another developer make changes? If there is some way to specify what dev tools to download, what is the difference between that and docker? If you aren't doing anything complicated, docker is just a good way to set up your dev dependencies. If you are doing something complicated I doubt WASM is going to help you.

h0l0cube 1 year ago |

> You can compile several languages into WebAssembly already. Languages that can't be compiled will eventually have their own interpreters compiled to WebAssembly.

A big constraint here is the memory model. Languages include a specification for memory allocation, deallocation, lifetime and garbage collection, and WASM has it's own way of going about that that is engine dependent. The performance lost from reimplementing the memory model within WASM could only be regained by going back to something that looks like containers.

Humphrey 1 year ago |

Disagree: While this might be the case for a handful of languages such as Rust of Go - Many lanugages need a whole lot of other stuff to run (eg, Python needs a lot bunch of dependencies).

mkl 1 year ago | |

I thought the same at first, but found Python Cloudflare Workers already run in WASM: https://developers.cloudflare.com/workers/languages/python/h...

Humphrey 1 year ago | | |

Ah interesting! Looks like that uses a WASM build of CPython to run your Python code - similar to how you can run python in your browser. Would you still have a heap of Python files?

tibbar 1 year ago |

The article starts out "In the year 2030, no one will remember Kubernetes", but focuses mostly on containers. Kubernetes solves a lot of problems that a runtime alone doesn't, like rolling upgrades, load balancing, etc. etc. However, focusing on the thrust of the article, which is replacing containers with code compile to WASM running in v8, it's still hard to agree. For example, apps commonly need a bunch of dependencies, WASM doesn't solve that problem, so you still benefit from building images in multiple cacheable layers.

I mean I don't enjoy Docker either, but I think it's more that there are many problems k8s + Docker help you solve, and WASM alone wouldn't solve a lot of them.

bborud 1 year ago |

There is one thing that makes WASM very awkward: projecting APIs into a sandbox.

If this was done in a way that works in mechanical sympathy with a wide range of languages I think WASM would be more successful. Making an API available inside a sandbox is painful. You have to manually roll something that can deal with memory, marshal calls and parameters etc. I'm not suggesting it is easy. I'm merely pointing out that this is what I see as the main obstacle to adoption.

I am not interested in "generic" access to system resources (filesystem, network etc) at all. In fact, I can't think of any scenario where I'd actually want to do that. I want to provide APIs that deal with external resources in narrowly defined ways.

It is much easier to do this securely when you explicitly have to provide functionality rather than say "here's the filesystem" and then try to clamp down access.

I want to use WASM on servers. Primarily in Go. I want to be able to create a bunch of APIs that provide narrow access to persistence and communication and project those APIs into the sandbox. In a manner that is interoperable and easy to use from various languages. I don't want to have to craft some application specific marshalling scheme.

If projecting APIs into sandboxes in a (mostly) language agnostic way that is natural, safe and easy to use, it'd be easy enough to write system interfaces. I have no idea why so few people see this as important since I feel it should be self-evident.

(And yes, being able to offer concurrency would be nice, but that's a much smaller issue than the problem of there being no good way to marshall APIs into WASM containers)

euroderf 1 year ago | |

Go development is ill-documented but just barely tolerable. Skip the BytecodeAlliance docs. Install WasmCloud's 'wash', write your WIT file, run 'wash build', and good luck with the error messages.

hansmayer 1 year ago |

The second paragraph is perhaps something you experience on a very small team in a very small company, but definitely not everyone's day-to-day experience and it sounds like the author would like to impose their own limited experience onto the whole industry. In a lot of companies the DevOps usually jump in and handle the entire management of the pipeline, including the build and release of containers. For most of developers, they still get to simply ship their features, I've rarely met classic developers 'optimising Docker build times'. Secondly, great technologies have intrinsic qualities and potential which get recognised instantly. Now there may be some hype following them, for sure, but it is these intrinsic qualities which silently drive the adoption of the new tech, not the hype. People starting building extensions and add-ons and more complex systems and suddenly you see it everywhere. WASM has been around for a few years now / anyone seen it make its way quietly into our working processes yet?

aqueueaqueue 1 year ago | |

I think WASM is misfortune because for most websites (forget backend for a moment!), anything it can do can be done better and faster using as JS and server side split. JS gets heavily optimised by V8. And add in the download time for the WASM and the learning curve and it isn't too attractive.

It needs something to make it a must have for some area of adoption. I just don't see it yet.

iLemming 1 year ago |

I vividly remember how I was young and stupid, and some people claimed that web components would replace everything. There was a guy in another team who kept bashing us for building things on top of React because "you'll see, very soon, in just a few months...just like you're having to rebuild from Angular, and someone before you had to rebuild from Backbone/jQuery..."

I've grown less young since then, and I can probably count numerous other claims for some great idea to replace "all this crap very soon." Turns out, "one-size-fits-all" solutions are almost always hype, sometimes not even backed up with pragmatic arguments. There are simply no silver bullets in our industry, especially in relation to web tech. Guess what? Some websites are still being built with jQuery, and maybe there's nothing wrong with that.

No, WASM not going to replace containers. At best, it will likely find its specific niches rather than becoming a universal solution. That's all.

thesz 1 year ago |

This is a post about shiny new thing author loves.

And author loves shiny new things [1]: "...use 10% of your time writing code (or telling AI to write code)..."

[1] https://creston.blog/stop-writing-code/

What about old, not shiny things?

For example, SQL is Turing complete and expresses simulation of data flow paradigm [2]. It is effectively executable on current massively parallel hardware and even scales horizontally, enabling safe transactional "microservices." Why should we embrace WASM, but not SQL?

[2] https://en.wikipedia.org/wiki/Dataflow_architecture

malkia 1 year ago |

No, it won't. Especially when comes to CPU or GPU intensive tasks... and not only that...

bovermyer 1 year ago |

It's mentioned in passing in the article, but I'm intrigued by the author's mention of how Cloudflare Workers interoperate. Besides the official documentation, are there any articles anyone can recommend on this topic?

kentonv 1 year ago | |

Cloudflare Workers run in V8 isolates, which are much lighter-weight than containers, with the ability to run thousands in the same process, and start up new ones quickly on-demand. For Cloudflare it's usually easier to start your application on the machine where it is requested, than to try to route to a machine where it's already running: https://developers.cloudflare.com/workers/reference/how-work...

The API construct that lets a worker call another worker (in the same process, in fact, in the same thread) is a Service Binding: https://blog.cloudflare.com/service-bindings-ga/

This is one type of "binding" or "live environment variable" or "capability". You configure it at deploy time, and then at runtime you can just do `env.SOME_SERVICE.fetch(request)` to call to your other worker: https://blog.cloudflare.com/workers-environment-live-object-...

There's a fancy RPC system, although it's (for now) centered on JavaScript so not as relevant to Wasm users: https://blog.cloudflare.com/javascript-native-rpc/

(I'm the tech lead for Cloudflare Workers.)

bovermyer 1 year ago | | |

Interesting. I only have a single Worker, but maybe I should experiment more with them.

Thank you!!

kodama-lens 1 year ago |

I don't think that WASM will replace containers. They will continue to move closer to each other but still have their advantages in different fields.

Right now I can run containers and WASM workloads in the same k8s clusters. I dont even have to think about it with runtimes like crun/youki or wasmedge. The OCI image format is the universal package format. It always has all its need and the tooling is broad and mature.

With containers I can basically put any app in any language in there and it just runs. WASM support is far from that, there is migration toil. Containers are and will be more flexible then WASM

imglorp 1 year ago |

"In the year 2030, no one will remember Kubernetes."

I feel like this prolog missed an important point. Kubernetes abstracts data centers: networking, storage, workload, policy. Containers implement workloads. They're at different layers.

And back to the article's point: WASM may well replace containerized workloads, indeed there are already WASM node runtimes for Kubernetes. Something else may well replace Kubernetes in five years, but it won't be something at the workload layer.

danpalmer 1 year ago | |

I came here to say this. Kubernetes is an ecosystem that represents a better way of running production workloads at scale for many orgs. People already use Kubernetes for VMs, and various different container runtimes are used by different cloud providers. If WASM does replace containers (unclear to me), Kubernetes would just support WASM, and stay largely similar.

stlava 1 year ago |

> In the year 2030, no one will remember Kubernetes.

I highly doubt that. Maybe there will be an evolution to k8s but fundamentally it solves a whole host of challenges around defining the environment an application runs in.

sargun 1 year ago |

No it wont. It's incredibly hard to build out a fully useful version of the Linux APIs, as shown to us by Cygwin, and WSL. Even if you built out a similar set of APIs, Linux itself offers a ridiculous set of interaction points where applications can tie together (for example, I can use inotifywatch to copy files out of my container as they're written). I feel like what you'll end up with is something like gvisor running on top of WASM. In which case, what did we gain from VMs at all?

cess11 1 year ago |

Can I run ephemeral Oracle databases and JBoss instances and Tibco EMS as WASM as part of a CI/CD flow? No? Then it's not comparable to containers.

I sure hope "developing on Cloudflare" is not "what the future looks like".

There are many, many VM:s and programming languages that are more or less easy to compile to many architectures and/or possible to run straight on a hypervisor or metal. JavaScript, Python, Lua, V, and so on. None of them are seen as container competitors.

SEJeff 1 year ago |

For folks interested in the current state of the art on sandboxing, here is a stab one of my former coworkers did:

https://github.com/firedancer-io/firedancer/blob/main/src/ut...

He researched chromeos process virtualization, moby (docker upstream), and chrome tab isolation. It’s all done ebpf magic on top of seccomp at its core.

kukiTsui 1 year ago |

You wouldn't want to miss MoonBit if you are interested in WASM. It is the most WASM-optimized language, quite promising. https://www.moonbitlang.com/

weinzierl 1 year ago |

Statically compiled portable binaries will replace containers.

Maybe not, but one can dream at least.

What do we need containers for, if we can build a service in a binary that you can throw on any Linux of the past 20 years and it just starts to serve network requests?

What do we need to support other platforms if the server world is one big Linux monoculture and the next best platforms are just a cross-compile away?

Why wouldn't I compile everything statically if containers don't share libraries anyway?

afiori 1 year ago | |

Statically linked binaries are perfect to run in lightweight containers

nunez 1 year ago |

You can totally run wasm via Docker through the wasm runtime. Given this, unfortunately, you will still need to admin Kubernetes.

0dayz 1 year ago |

Forgive me but I've heard the heralding new age nay revolution of wasm is coming anyday now and it hasn't and probably won't.

I don't doubt that wasm has potential, but personally I imagine more esoteric use cases as the go to than necessarily the replacement for containers (where my money is more on unikernel).

ninetyninenine 1 year ago |

Naw.

The purpose of docker is like a VM. To simulate the running of two or more server machines with OS's to run on one machine.

wasm is like java.

neom 1 year ago | |

...you're essentially turning the host OS into both a resource manager and isolation boundary enforcer, which is... kind of what hypervisors were specifically designed to do, just at a different level. When the container companies were all starting to come out, I never thought it was a good idea, given what I was building I never said anything because "of course the VM guy would not like containers" - I thought many times about what an ISO+VM "container" product would look like but at the time it would have been hard to match the performance of containers even if we could have gotten the developer experience super good. VM: Cold start: ~10 seconds with an optimized ISO, Management overhead: ~256MB baseline, Consistent performance profile. K8s: Cold start, ~30-50 seconds (control plane decisions + networking setup), management overhead: 1-2GB for the control plane alone, more variable performance due to overlay networking.

imo real question is: at what scale/complexity does k8 overhead get amortized by its management benefits? For a number of services, I suspect it never does. I will dutifully accept all my downvotes now.

openquery 1 year ago | | |

I haven't played around with hypervisors much but the whole point of k8s is not just isolation but all the primitives the control plane gives you which you don't need to implement. Things like StatefulSet, ReplicaSet, Volumes, HorizontalPodAutoscaler, Service, DNS, ConfigMaps, Secrets, Accounts, Roles, Permissions etc.

Also the container runtime which is containerd by default I believe can be switched out for micro vms like Firecracker (never done this though - not sure how painful it is).

slt2021 1 year ago | |

or wasm is just faster client-side javascript

pjmlp 1 year ago | | |

More like return of Applets, Flash, Silverlight, ActiveX.

And that is great, thanks to it is all turtles to the way down, I can have my plugins back, now running on WebAssembly, that is the only thing I care about it.

jpillora 1 year ago |

They're different things, solving different problems:

- Containers are wrappers for binaries. Any binary can be contained, and when run, it gets a constrained (fake) view of the kernel.

- WASM defines a portable binary format. WASM is intermediate-representation, in the same vein as Java byte-code.

You could reasonably put WASM binaries inside containers

quotemstr 1 year ago |

Right. Moore's law has made too much progress. We must claw back some slowness! Let's take code that could run securely at full speed and run it in emulation at half the speed instead. That'll keep those menacing hardware performance improvements at bay a little longer.

bloopernova 1 year ago |

What sort of tooling is required for wasm? Let's say I wanted to deploy a middle tier in our app, consisting of some nodejs code that talks to an external database.

We'd use a Dockerfile, install nodejs or use a source image to build from. How does that work for wasm? Does it have layers to reuse?

openquery 1 year ago | |

You need a toolchain to compile to wasm and a runtime to run it.

awill88 1 year ago |

I think this author is so far off the mark that it makes me wonder if they were high when they wrote this

orliesaurus 1 year ago |

lol I initially thought dylibso was the author, I was mistaken. That being said - WASM has been steadily improving over time, yet it hasn't quite achieved mainstream adoption.

I'm curious what's holding it back?

It seems like despite its technical advancements, WASM hasn't captured the public's interest in the same way some other technologies have. Perhaps it's a lack of easily accessible learning resources, or maybe the benefits haven't been clearly articulated to a broader audience. There's also the possibility that developers haven't fully embraced WASM due to existing toolchains and workflows.

[1] https://github.com/dylibso

evacchi 1 year ago | |

> lol I initially thought dylibso was the author

as a Dylibso employee, I am wondering what made you think that :D at Dylibso we advocate for Wasm for software extensions, rather than an alternative to containers!

orliesaurus 1 year ago | | |

Because of the topic. I find you guys are the only people advocating for Wasm in general, in public.

dowager_dan99 1 year ago |

Some pretty bold claims with what I felt was shaky justification and a simplistic understanding of the foundations.

>> I am a software developer for a top 100 app. I've written code you've probably used. That makes me qualified to say stuff.

Ah... that explains a bunch of it.

pjmlp 1 year ago |

It is so funny seeing folks reinventing Java EE application servers, or IBM i, z/OS.

mikewarot 1 year ago |

Capabilities based Operating Systems will replace containers. WASM is a stepping stone to help the world better impedance match them conceptually.

If someone tacks on file system access to WASM, the whole system becomes worthless.

jdougan 1 year ago | |

A while back someone claimed to me that WASI was structured as capabilities. True/false?

mikewarot 1 year ago | | |

True

  WASI Design Principles

  Capability-based security
  WASI is designed with capability-based security principles, using the facilities provided by the Wasm component model. All access to external resources is provided by capabilities.

  There are two kinds of capabilities:

  Handles, defined in the component-model type system, dynamically identify and provide access to resources. They are unforgeable, meaning there's no way for an instance to acquire access to a handle other than to have another instance explicitly pass one to it.

  Link-time capabilities, which are functions which require no handle arguments, are used sparingly, in situations where it's not necessary to identify more than one instance of a resource at runtime. Link-time capabilities are interposable, so they are still refusable in a capability-based security sense.

  WASI has no ambient authorities, meaning that there are no global namespaces at runtime, and no global functions at link time.

Source: https://github.com/WebAssembly/WASI/blob/main/README.md

fergie 1 year ago |

> You have the option of writing your worker in JavaScript/TypeScript, or compiled WASM.

Is there any compelling reason not to just compile TypeScript to WASM? Why should it have JavaScript as its compile target?

MortyWaves 1 year ago | |

The closest to that is AssemblyScript which is terrible and painful to use with a broken developer tooling story.

sebstefan 1 year ago |

>A very obvious argument against WASM succeeding is the Java Virtual Machine (JVM). It's almost exactly the same promise: write once, run anywhere. [...] The biggest limitation is that JVM bytecode cannot run in a web browser

The draw of WASM is to be able to have your code run in a browser tab exactly as it can run on your local hardware, as it can run if you embed it in your own application, with the only thing moving being custom syscalls between the 3

The biggest limitation of the JVM was that it's closed

You can spin up your own WASM interpreter and integrate it anywhere you like. It wouldn't be an impossible bridge to cross, it's RISC, it's open, there's many open implementations. Is it even possible to write your own JVM from scratch?

stego-tech 1 year ago |

While I don’t doubt the utility of WebAssembly, I do have to kind of roll my eyes at the ignorance of history going on.

Servers were the future of code after mainframes because of simplicity and write-once run-anywhere code but without all the complexity, they just needed similar networking and storage solutions as mainframes had to be viable first.

Virtual machines would be the future of bare metal servers, allowing code to be written once and run anywhere, eliminating the complexity of bare metal servers. VMs just needed better networking and storage first to be viable.

Containers would replace the complexity of VMs and finally allow code to be written once and run anywhere, once orchestration for storage and networking was figured out.

Serverless would replace containers and allow code to be…

You get the idea.

The only thing holding back code from truly being “write-once, run anywhere” is literally everything that keeps it safe and scalable. The complexity is the solution. WebAssembly will start with the same promise of a Golden Path for development, until all the ancillary tooling ruins the joy (because now it’s no longer a curiosity, but a production environment with change controls and SOPs) and someone else comes along with an alternative that’s simpler and easier to use, because it lacks the things that make it truly work.

I don’t particularly care how it’s packaged in the end, so long as it runs and has appropriate documentation. Could be a container, or a VM template, or an OS package, or a traditional installer, or a function meant for a serverless platform.

Just write good code and support it. Everything else is getting lost in the forest.

ok_dad 1 year ago |

We’re still using COBOL mainframes in 2025 in places so I’m sure whatever is the next trend in computing will be great, but I’m sure we’ll still be using k8s (and COBOL) in 2125.

jsheard 1 year ago | |

> but I’m sure we’ll still be using k8s (and COBOL) in 2125.

If you want a vision of the future, imagine a bare metal hypervisor hosting Linux hosting K8S hosting V8 hosting a WASM-based IBM mainframe emulator running COBOL.

bbkane 1 year ago | | |

This reminds me of the K8s keynote where Kelsey Hightower runs Fortran in K8s- https://m.youtube.com/watch?v=oNa3xK2GFKY . It's a fun watch!

tehjoker 1 year ago | | |

It's running on a quantum computer emulating a classical computer ofc.

mabedan 1 year ago |

> by deploying WASM in V8 sandboxes, you get all of the developer benefits of microservices with all of the runtime benefits of monoliths

No oversimplification to see here.

Evidlo 1 year ago |

Does anyone remember a presentation on YouTube that described a hypothetical future where everything will be running inside a VM in a browser?

akdas 1 year ago | |

The Birth and Death of Javascript. One of my favorites! https://www.destroyallsoftware.com/talks/the-birth-and-death...

Evidlo 1 year ago | | |

Thanks, that was it!

cprogrammer1994 1 year ago |

Confusing hammers with drills is a big mistake. Similarly, the problems WASM solves and the problems containers solve have little in common.

ein0p 1 year ago |

I've yet to see a single example of WASM in the wild. How is it supposed to "replace" anything, if nobody is using it?

zfg 1 year ago | |

You've likely had WebAssembly running in your browser but didn't even realize it.

Firefox also lets add-ons run WebAssembly modules which is something that uBlock Origin has made use of for a long time:

https://github.com/gorhill/uBlock/wiki/uBlock-Origin-works-b...

mdaniel 1 year ago | |

1Password actually bundles it with everything they ship (browser, desktop, even their golang cli): https://github.com/1Password/onepassword-sdk-go/tree/v0.1.7/... and then use extism to cross over its boundary https://github.com/1Password/onepassword-sdk-go/blob/v0.1.7/...

They compiled their rust libraries to wasm and it allows reuse of those rust bits across everything

The other famous example I know of, but haven't used, is Figma https://www.figma.com/blog/webassembly-cut-figmas-load-time-...

WhereIsTheTruth 1 year ago |

Just like with systemd ruining every cloud infrastructures, here we go with WASM

Who wants everyone to be forced to use the same BigTech slop?

pluto_modadic 1 year ago |

kubernetes is an endless employment engine for operations staff (it's kinda the opposite of "anybody can write react, so react devs are now cheaper", instead you're constantly maintaining a piece of junk k8s stack).

no way someone would engineer their way out of not over-engineering a kubernetes stack.

The other bit of this is that FNaaS pricing is crazy expensive. Unless someone goes an order of magnitude cheaper than cloudflare's wrangler offering on the edge, I don't see it happening. You get none of the portability by writing yourself into a FNaaS cage like cloudflare or fastly.

Companies start off with business logic that solves a problem. Then they scale it (awkwardly or not) as it balloons with customers. Then they try to optimize it (sometimes by going to the cloud, sometimes by going back to their own VMs). VCs might not like "ending growth", but once you're on a stable customer basis you can breath, understand your true optimal compute, and make a commitment to physical hardware (which is cheaper than cloud scaling, and FAR cheaper than FNaaS).

The piece that might travel the entire way with you? Containers and Kubernetes.

phendrenad2 1 year ago |

This has to be the highest word-count-in-replies-on-hackernews-to-word-count-in-entire-blog-site ratio ever.

LunicLynx 1 year ago |

Someone does not understand what kubernetes is. Kubernetes or something like it will continue to exist.

poisonborz 1 year ago |

Surely this will be the year of WASM!

tomrod 1 year ago |

That would be cool.

It's been about 3 years since I dug into WASM and was bewildered about how to use it.

Is it time to dig back in?

euroderf 1 year ago | |

Try the Component model.

gedw99 1 year ago |

My golang WASM is half the speed of my golang native.

That’s double server costs.

It’s golang so maybe that’s why ?

ACELARE 1 year ago |

I need contributers for this Wikipedia page - https://en.wikipedia.org/wiki/User:Dr.SeemaMidha

Fellow Wikipedians may show their interest in the comment section.

SeemaMidha 1 year ago | |

How May I Help You?

SeemaMidha 1 year ago | | |

The Wiki page you want to create is disallowed by the Wiki Bots.

The exact uniform resource location of the concerned Wiki page is https://en.wikipedia.org/w/index.php?title=User:Dr.SeemaMidh...

The displayed uniform resource location of the concerned Wiki page is https://en.wikipedia.org/wiki/User:Dr.SeemaMidha

xyst 1 year ago |

Definitely a dead take. WASM has its merits but it’s not a panacea.

il-b 1 year ago |

WASM just moves vulnerabilities to the wrapping code. If you use FS, then you still have to prevent the wrapper from stealing your /etc/passwd, so container it is

t2o34h234234 1 year ago |

Suprised Nix isn't mentioned here.

oppositelock 1 year ago |

Why does anything need to replace anything?

Containers, VM's, physical servers, WASM programs, Kubernetes, and countless other technologies fill niches. They will become mature, boring technologies, but they'll be around, powering all the services we use. We take mature technologies, like SQL or HTTP for granted, but once upon a time, they were the new hotness and people argued about their suitability.

It sounds like another way to distribute software has entered the chat, and it'll be useful for some people, and not for others.

nottorp 1 year ago |

microservices, serverless...

Truly buzzword compliant, this article.

zombiwoof 1 year ago |

So dumb - Shoresy

tonymet 1 year ago |

My boomeritis flares up when I hear someone trying to sell me on 10x-ing instructions . I think we need a new unit of inefficiency called Matrioschkas . The Swedes call this Torta-på-Torta or a cake in a cake (in a cake..)

gnarbarian 1 year ago |

we can only hope.

diego_moita 1 year ago |

Hmm, not sure...

Author's argument is "because it is easier today and will be as powerful as containers in the future".

Well, what about it gets as powerful but 3 times more complex? Frankly, I find it quite messy to develop WASM in C++ without downloading an emscripten ...container. Yeah, AFAIK, there is no WASM compiler in WASM.

Oh an there is the *in the browser*, also. Yeah, but the truth of the matter is that most WASM frameworks have a mediocre performance when compared to JS (because of the memory isolation).

In this job we love new projects. We like them so much that we keep forgetting that the vast majority of them fail.

kristjank 1 year ago |

This webdev notion of abstracting 30 layers of complexity just to run bytecode is borderline lobotomizing and should be blamed for 8,000,000,000 Bytes of RAM not sufficing for a slightly-above-average desktop computer nowadays.

$ sudo podman run -it --runtime=/usr/bin/runsc_wrap -v /:/app debian:bookworm /bin/bash root@7862d7c432b4:/# ls /app bin home lib32 mnt run tmp vmlinuz.old boot initrd.img lib64 opt sbin usr dev initrd.img.old lost+found proc srv var etc lib media root sys vmlinuz root@7862d7c432b4:/# uname -a Linux 7862d7c432b4 4.4.0 #1 SMP Sun Jan 10 15:06:54 PST 2016 x86_64 GNU/Linux