iswasmfast VS neon

At a glance, the bindings for wasm copy the data,

https://github.com/zandaqo/iswasmfast/blob/54bbb7b539c127185...

If the running code is short enough then that copy might easily make the wasm version much slower. That is indeed a known downside of wasm (calls to JS are somewhat slow, and copying of data even more so - wasm shines when you can avoid those things).

If it's not that, then a 10x difference suggests you are running into some kind of a VM bug or limitation.

WASM has its moments, as you can see in this[1] benchmark it outperforms JS and native addons on certain tasks.

Since the bottleneck with native addons is usually data copying/marshalling, and we have direct access to WebAssembly memory from the JavaScript side, using WebAssembly on this "shared" memory might become the best approach for computationally heavy tasks. I wrote about it a bit here[2].

[1] https://github.com/zandaqo/iswasmfast

A few years ago I did similar comparison but in context of Node.js and sans manual optimizations: https://github.com/zandaqo/iswasmfast

In my work, I have come to conclusion that it seldom pays off to go "native" when working with Node.js. More often than not, rewriting some computationally heavy code in C and sticking it as a native module yielded marginally better results when compared with properly optimized js code. Though, that doesn't negate other advantages of using said technologies: predictable performance from the start and re-using existing code base.

Great interview!

Love how much thought is being put into what you “gold-plate”. I’ve always felt that my best work comes around on round two (or three or four…).

Curious what you are planning for the ability to script the configuration? I haven’t played with zed much yet; is it possible today? Would something like Neon [1] help bridge the gap from VSCode and old Atom users?

[1]: https://github.com/neon-bindings/neon

Neon

Is there a third option? Surely node has a way to directly call native code, similar to Python's C extensions? Some Node equivalent of PyO3? For example, I found neon which promises "safe and fast native Node.js modules".

Have a look at https://crates.io/crates/napi and https://crates.io/crates/neon which allow you to call rust from node. We went with napi but they're both pretty good.

Just to add: N-API is incredibly underrated. Then again, maybe the lack of a strong native modules ecosystem is an indicator that the pure JS ecosystem is just so good. But man, got something computationally intensive? Just offload it to Rust with Neon or something. Got some proprietary bit of code in your product? Build a native module.

> rust is not well-suited for interfacing with FFI

How so? Packages like neon [1] and rustler [2] suggest otherwise. I'm using both of those in a real product (I'm using neon directly, to write native modules for an Electron app; on the back-end, I depend on an Elixir package that uses rustler).

[1]: https://github.com/neon-bindings/neon

[2]: https://github.com/rusterlium/rustler

You can use https://github.com/infinyon/node-bindgen, https://github.com/neon-bindings/neon, or https://github.com/napi-rs/napi-rs for Node.js libraries, https://github.com/PyO3/pyo3 for Python libraries, https://rustwasm.github.io/wasm-bindgen/ for WebAssembly, and https://github.com/rust-lang/rust-bindgen for C libraries!

They can use Rust to speed up Nodejs through https://crates.io/crates/neon for example

I’m not prompted again while actively using my laptop. When it’s time to switch to an open source project, I’m seamlessly prompted for my GitHub key.