Ruby on WebAssembly | Hacker News Reader

Ruby on WebAssembly

blacktm.com

91 pointsgeospeck33 comments

Just a thought experiment...

Would this allow for full stack ruby apps?

Writing a client side router and controllers in Ruby on Rails compiled to web assembly?

If you could just toggle in production.rb if you want your routing to be client side or server side and the framework could transparently manage that for you.

In theory you could already do this with Opal (https://github.com/opal/opal).

In practice too: http://www.voltframework.com

Nice.

Anyone else getting a "Connection Lost..." message as soon as they visit the page?

Does not seem to be actively developed, however. Last commit was in early 2016: https://github.com/voltrb/volt/

I believe Hyperloop[0] tries to accomplish something similar

[0] http://ruby-hyperloop.org/

There is no Ruby on Rails for mruby, yet.

What are the differences between mruby and MRI that prevent this?

mruby is an embedded language so it's missing a lot of the built-in features that MRI has.

yes, and it's not only ruby doing this, various other languages are doing it also.

So it's going to be interesting to see what kind of disruption that has on javascript on the client side.

Why would someone go through so much trouble to use a language that will run much slower than JITed javascript?

I think most people miss that right now webasm is good for run speed, size, and loading speed, but is not geared nearly as much towards using any language in a web page, since IO needs to be exposed to javascript.

JavaScript isn't everyone's cup of tea, and performance isn't always a huge concern :)

The more other languages I learn, the more often I come back to Ruby. I'm excited to see it becoming a more portable language, and I think it'll make a good language for web clients someday.

Again, all the IO still has to be done in javascript, you can only do raw processing in web assembly right now.

If you try to write the web assembly part in ruby, you are sending your users a run time and using an interpreter that is itself being JITed, purely to transform some amounts of data between IO from the user, including any information to and from the DOM.

> performance isn't always a huge concern :)

This is what concerns me a little with WASM. There are already too many web development experiences that prioritise developer experience and neglect user experience, I'm wondering what future we're walking into where we bundle three different standard libraries, ignore binary size, etc etc

I've never understood this take on things, though I'm ready to if it can be explained to me. :)

To me, it seems that the user experience vs dev experience trade off is subject to market forces and if it swings too wildly in either direction, a competitor will come through and wipe the floor with everyone else, no? It's always seemed unnecessary to me to worry about the effects of _more_ options, at least in the context of application development anyway.

There are lots of things you can do that aren't performance bound: web pages focused on content, 2D games, simple forms.

I thought the same thing when Node.js started to become popular: why would anybody go through the trouble to set up an environment to run single-threaded, interpreted applications on a server when we already had C/Java/.NET/etc?

It turns out people like to use the languages/environments they already know.

There are plans for WASM to add features like GC, threads, PIC, direct DOM access, etc. So when those arrive, this can port over and bring less runtime.

And there is currently pretty direct access to a canvas.

I hope we soon get Lisp on WebAssembly so we can run a full OS (emacs) in the browser.

We already have these two:

* Schism [0], R6RS Scheme.

* Arboreta [1], Common Lisp.

[0] https://github.com/google/schism

[1] https://github.com/Arboreta/arboreta-wasm

Curious how fast/stable Ruby->wasm is on the frontend. I had a horrible experience with scaling a large rails app, but the usage patterns for server vs client are very different.

I haven't played with wasm yet and am waiting a bit for a "best language" consensus to emerge. If I was to bet on a winner, my money wouldn't be on Ruby, but I've been wrong many times.

Mruby has captured my attention for quite a while now, especially the ability to compile and run its own bytecode as a module. The memory handling seems good and want to try running it with Cairo GL for iOS sometime for some immediate mode rendering.

How would you use features like event listeners and other web APIs from client-side mruby? I guess this is a question about WebAssebly in general: does each language that gets ported over have to re-implement those APIs?

wasm has something akin to a syscall interface to talk to the JS side, but you can't just call arbitrary JS.

To clarify this a bit, webassembly modules declare external functions they'd like to call. When you instantiate the module, you hook JS functions up to those names. So, you can "call arbitrary JS" in the sense that there's no restrictions on what JS is in those functions, but you can't "call arbitrary JS" in the sense that the module has to list up-front what it'd like to call and it's the instantiator's job to provide those things or decide to not instantiate.

Rubies magic evaporated when I realized that its logic is unintuitive / broken:

``` puts true and not true >>> true x = true and false >>> true if 0; puts 'true';end ```

breaking backwards compatibility with every rails upgrade didn't help.

Similar bad behaviour in kotlin

and/or/not have different precedence than &&/||/!.

The symbol versions of each of those would behave as you would expect. However, I can’t say much in favor of the existence of the word forms.

Here’s when you’d use them

http://www.virtuouscode.com/2014/08/26/how-to-use-rubys-engl...

The word forms are not operators, they're control flow, like "if"

So, your first two complaints are you not understanding Ruby operator precedence, not Ruby logic being broken, and the other is you not understanding Ruby truthiness (null and false are not truthy, all other builtin/stdlib values [and conventionally all other values] are falsely.)

And the final complaint was about Rails, not Ruby.

Hasn't the use of "and" been considered a bad practice for years?

for boolean operations yes... for control flow it's debatable.

Reply on news.ycombinator.com