Debugging WebAssembly outside of the browser
hacks.mozilla.org
hacks.mozilla.org
I actually enjoy creating plain server side rendered web applications with just a dusting of client side Javascript where it makes sense. The development flow is simple and debugging is easy.
But well, I guess people will do it anyway, let's see how this plays out in the long run.
On the contrary, for many people performance isn’t a factor, but they find the idea of using the same language (and thus code) client-side and server-side appealing.
This was one of the key features and benefits of NodeJS, and I won’t be surprised when I see others trying to replicate the experience via web-assembly.
What I want to say is, I question the premise that there are as many backend devs who just don't do frontent stuff because of JS as there were frontend devs who didn't do backend because JS wasn't an option.
On the other hand the industry gets bigger by the day, maybe even a small percentage of devs doing Python frontends will be thousands of people :)
`apiRequest(method, url, requestParameters, headers, body)`
`databaseQuery(credentials, sql, bindings)`
The past 3-5 years of my professional career have just been shuffling data around from one point to another.
I installed RationalRose once, and... that was it. Code generation tools suck.
It's a mostly MS shop and you'd be surprised how many developers in orgs really just don't do front end work because of JS.
Every cycle your app wastes is a cycle another app can't use. It's a fraction of a watt that adds up over time, draining batteries faster, drawing electricity from the power grid and burning carbon fuels.
Each individual cycle may be cheap, but when we have a culture of development that doesn't respect performance, the waste adds up and has a real impact on the world. Just like all other resources, in aggregate, waste is harmful.
Even on the spectrum of "developer productivity", you have to seriously consider if the operational cost of needing beefier servers to run slow-language-X is less than the operational cost of hiring fast-language-Y developers.
I doubt anyone has done a serious study of the issue. Say C++ is 15x faster than Python. You might be able to say that a C++ dev is 2x the cost of a Python dev. Is the ratio of development cost to server cost more than 7.5x? What about other languages that aren't quite so fast, but aren't quite so expensive? You might find that C# is 10x faster than Python, but devs are only 1.25x the cost. Now your ratio of dev cost to server cost needs to be at least 8x to come ahead.
And honestly, good developers are expensive, no matter what language they're working in. Choosing a programming language to be able to optimize for cheap developers could be optimizing for bad developers who can't create the features you need. They might be half the price, but can they get the job done--after all the reworks and defect fixes and other learning curves--in less than 2x the time? I've never seen a programming language on its own have that kind of impact on development.
The point is not that "Language X is universally better than language Y". My point is more that "some languages are so incredibly wasteful that you seriously have to start considering whether or not you're saving money".
You make a good argument about the potential costs abstractions when they are applied at a very large scale. You are however ignoring the cost of things that may be prevented with high-level language features, like for instance errors in memory management which in my opinion are far worse than wasted cycles. I'd wager most would choose a marginally higher power bill over Heartbleed.
Again, some languages are unnecessarily wasteful of cycles.
The ideal language isn’t the most efficient language but one that is fast to develop, and leaves a possibility to optimize later. I would think languages like Nim and Rust are best in that regard, and more recently JavaScript.
I think those two things are at odds with each other. I think a lot of technical decisions are being made on a short-sighted business level. And I think a lot of people on the technology side have inculcated too much of the business message.
I'm not arguing against ever using languages like Python or Ruby or PHP or whatever. But I think a lot of people make assumptions that their language choice doesn't matter. In a lot of the same ways that building an entire economy on carbon fuels was "easy", it only worked because of externalities. As a profession, we need to be taking a longer view of our craft.
I don't think that it is true that it's impossible to make C++ secure. I don't think that it's true that--say--Java and C# are less productive than--say--Python or Ruby. On a surface level, certain things are easier, but once you start digging into real problems, there isn't much difference. And experienced developers in any language will be far beyond that surface syntax.
I just think that, as a profession, we have our priorities way out of whack.
You make a few good points, but keep in mind that software development is both a centralization and planning problem. And exercising planning requires having accurate feedbacks.
Transpilation is a better option if you just care about using the same language because you have better control over the DOM and you can use HTML and CSS markup (which is the best widget set across any platform).
https://webassembly.org/docs/faq/#is-webassembly-trying-to-r...
It probably won't replace solutions that already work well, but it might be an option for the things that currently don't work.
There was discussion to add `dl_open` + `dl_sym` to WASI but it got shot down. WebAssembly seems to be in a weird state of "look, I can run in and out of the browser, but I can't actually do anything useful out of the browser, and I can't access the DOM without going through JavaScript in the browser"
(e.g. see https://github.com/wasmerio/wasmer-c-api/blob/master/wasmer-...)
There's similar embeddings for other languages here (python, go, ruby etc...):
If Maya had an embedded WASM runtime it could support plugins which are fast (at least much closer to native speed than Python scripts), and you only need to distribute a single WASM blob.
https://www.fastly.com/blog/announcing-lucet-fastly-native-w...
Lucet
wasm-jit-prototype
None of them will let your WebAssembly code call an exported function from a shared library.
As an exercise, try to call https://docs.microsoft.com/en-us/windows/win32/api/winuser/n... from WebAssembly.
> this seems like a huge layered mess just waiting to trouble those poor devs.
WASM is a VM. It's less complicated than a javascript engine. How complicated it seems in daily practice is going to come down to how good the tooling is.
I knew somebody was going to object to that little factoid despite its irrelevance to the point at hand. I've updated my comment to remove any reference to any specific in-browser debugger.
Yes, I used visual studio. You could debug the server in the same session. It was pretty sweet.
But I believe that the more tooling a stack needs, the more wobbly the stack gets. The more wobble the more error prone and less fun to work with.
WebAssembly is a VM, with an accompanying instruction format.[1]
> Vendors that only allow use of WebAssembly are leaving performance and compatibility on the table.
It'd be interesting to know what you're thinking of when you say that. For example, is Cloudflare leaving performance and compatibility on the table by using WebAssembly instead of Linux containers for Cloudflare Workers?
Webassembly is a perfectly good container and would by default have crossplatform capability.
This post is specifically "Debugging WebAssembly Outside of the Browser," but the title on HN was unfortunately truncated.
In typical applications, the vast majority of bugs should happen in the platform-agnostic parts, so debugging a native build totally makes sense. It would still be great if WASM would be as trivially debuggable as native code.
IMHO proper source-level debugging support in the browser dev-tools (or remote-debugging via VSCode) would make a lot more sense than debugging in gdb/lldb though.
As for your second question... there's motion towards making wasm runtimes other environments, like devices or server-side. Kind of like the JVM or CLR, but closer to the metal (e.g. no garbage collector). The advantage of the server-side is the same as node.js, sharing code with the client. The advantage for other environments is a portable file format with performance characteristics closer to native. My impression is that the reception is less enthusiastic than wasm in the browser.
I think the intention of OP is that you compile the same Rust code to a native x86 or ARM binary and debug that. Most bugs are ISA-agnostic so that approach totally makes sense in many situations.
That's how I'm debugging my WASM code compiled from C/C++, and that also works automatically with IDE debuggers that don't know about WASM (like Xcode's or Visual Studio's).
So there's effectively another layer of sandboxing versus a native binary, and you might need to track down how your program behaves in that sandbox.
Similarly, if you're working with a program that imports several WebAssembly modules, you'll need a way to debug the combined system, versus any single module in isolation.
[1] http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.108...
The sandboxing story also seems to be much stronger with WASM than either of those (where sandboxing felt more like an afterthought at best).
In other words: WASM still relies on a runtime/VM, but the difference is that the runtime/VM is astronomically better for the intended use case (and also, incidentally, a presumably-unintended use case) than most existing runtimes/VMs.