JVM forces you to write in Java or a JVM targeted language but WASM lets you compile any language that creates a WASM backend.
> JVM forces you to write in Java or a JVM targeted language
And this
> WASM lets you compile any language that creates a WASM backend
Are basically the same thing.
There’s no fundamental reason that all these languages couldn’t target JVM byte code instead of WASM. It never happened, not nearly as much as WASM backends are, but it could’ve.
? -> CORBA -> RMI -> SOAP -> REST -> GraphQL?
? -> SOA -> Microservices
? -> EDI / X12 -> XML -> JSON
p-code -> ? -> JVM -> WASM
Burroughs, all Xerox PARC, Lisp Machines, OS/400, Oberon, Limbo, original Modula-2, QuickBasic, Amsterdam Compiler Toolkit, VB, ...
Or EDI?
It's like saying we had the Model T, but people just keep inventing new cars.
And thanks to stuff like this, contemporary browsers are now so complicated that they only run on the top handful of platforms. So how is it progress? I bet JVM still runs more places than modern browsers.
> VM forces you to write in Java or a JVM targeted language but WASM lets you compile any language that creates a WASM backend.
WASM forces you to write in something that has a WASM backend just like JVM forces you to write in something that has a JVM backend. It's just the same all over again. And again.
But they're not doing io_uring style syscall queues.
Superior operating system runtime interface and POSIX don't rhyme. The fossilization of POSIX on Unix-like systems, endlessly piling stuff on top of that creaky foundation is probably the single biggest issue holding back the future of computing.
WASIX is probably a pragmatic design if you want to run your existing Unix programs on top of WASM. If anything, it's for the past of computing.
I encourage you to read the design documents for the Fuchsia operating system, especially those for the Zircon kernel [2] for a fresh, legacy-free take on a system call interface.
[1] https://www.microsoft.com/en-us/research/uploads/prod/2019/0...
what you must realize is that one does not have to use a syscall if they don't like it in (e.g. just use rust to code your app and it will never call the fork syscall)... but taking that choice away from others who want to use it is unfair as its denying them access to the WASM ecosystem (e.g. bash)
OpenVMS for example does not provide fork(). What it does provide is vfork() by doing some internal book-keeping within the C run-time library and delaying the actual child process creation until exec() is called [2].
The POSIX specification eventually standardized posix_spawn() [3] as a partial alternative for fork() due to its numerous issues, some of which are detailed in the rationale section of its specification. Sadly, it appears its usage is not as widespread as it could be.
I'm not blaming the WASIX project for providing POSIX semantics since running POSIX-compliant programs is an explicit design goal. What I do wish is that more people realize that POSIX isn't the pinnacle of operating system interface engineering or some sort of holy scripture that shall not be questioned. It's 1970s legacy from long defunct hardware and obsolete software (think PDP-11 and Version 7 Unix) that was written down as a specification in the 1980s.
[1] https://docs.rs/libc/latest/libc/fn.fork.html
The following technologies were all silver bullets:
* ActiveX, COM Object model, XPCOM
* Unified Modeling Language (UML)
* Extensible Markup Language (XML)
* Computer-aided software engineering (CASE)
* Java Virtual Machine
* Ionic, React Native, Qt, Gtk, Flutter
Something tells me that the problem is bigger than anyone can chew and the abstraction solution is sometimes more complicated than the underlying thing being abstracted.
I think WASI and WASIX is an EXTREMELY important API for the future of computing. It's a chance to create a superior operating system runtime interface.