Rust Programming Language EuroRust 2022, 4 Nov 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: No free lunch: Limits of WASM as a bridge from Rust to JS - Alberto Schiabel - EuroRust 2022

Description

Alberto Schiabel
Senior Software Engineer and Former Startup Co-Founder

Traditionally, Node.js has delegated the task of writing complex CPU-intensive logic to C++, but the increasing adoption of Rust and WebAssembly has led to a paradigm shift. In fact, Rust code can be compiled to WASM and be imported in a JavaScript (or even TypeScript) source file - for instance, Seed and Prisma follow this approach -, but that doesn’t come without limitations and gotchas, even for relatively small projects that abide to standard Rust patterns. From silenced warnings and obfuscated panic errors to structs that cannot be serialized and typed automatically, the path of porting Rust code to a JS app in production is a steep one, even when we don’t consider the I/O limitations that WASI should address.

In this presentation, we will look at a language parser written in Rust, compiled with wasm-bindgen and interpreted by Node.js, observing some limitations for production use cases and discussing alternatives. There’s no free lunch: WebAssembly - albeit useful - comes with its own set of challenges, and I trust this talk will help you navigate potential issues before they impact your deadlines.

A

Hi everyone so nice to be here so I'm, going to talk about limits of webassembly as a bridge from rust to top to JavaScript and typescript. So a little bit about me, uh I'm bertos on GitHub I'm, an open source engineer at Prisma, but I'm. Also, a freelance consultant I've been mostly working with the ascent typescript since 2015, but they've also tried a few other other languages like super sports in Haskell. More recently, I've been uh really enjoying rust since 2020 and I'm from the function functional programming.

A

So um we already had a great position about webassembly for games. Let's uh get a bit more into that. So first of all website is not a language right. It's just a portable binary format that basically ships its own virtual machine uh based on stocks and it allows within other languages to be loaded and run in JavaScript environment uh and any JavaScript runtime. For this talk, I'm going to focus on uh node.js modules can be imported as if they were other standard uh JavaScript modules.

A

So it's pretty handy um ebm, for instance, made um a benchmark a few years back and they realized that the same logic written in Rust was and then converted to um to be imported. As a was module in node.js was 50 times up to 50 times more faster than the SIM code, written in JavaScript or um CPU bound tasks, and it's well supported uh since on node 8., all right. So we're going to focus on uh transforming rust logic and rust data structures um via wasn't to import them in JavaScript and in particular in typescript.

A

um We're gonna attempt to realize that the structures of increasing level of complexities, because it's very easy to um convert, for instance, numbers via the foreign function interface, it's much harder when you get box structs and things like that and we're gonna go over. Some awesome binds and Magic um as a little demo. I don't have a game to show you like the previous uh presentation from Francois, but they have a language first parser and validator uh written in Rust and we're gonna see how uh we can execute that in node.js all right.

A

So, let's start with serialization of data structures AST by the way stands for uh office, industry, I use for the parser so again, um Scholars. Let's take a simple struct of scholar: values like booleans or unsite integers characters easy to translate. Vr was binding. You just need to add the macro on top and you need to compile that with this increment system before and we get something um only that works for typescript like we get a type definition we can uh use. uh We can run JavaScript with that.

A

uh It's a little bit cumbersome like it has some um methods that we don't really expect. Basically was binding, leaks out some internal details to the type, and that makes it a bit uh more uncomfortable to use. uh When you see the final variable of that type, idiomatic type script will be the one at the bottom, just a record uh with that. Without that free method, you see at the top um moving our strings with strings. We already see the first computation errors. Why is that? Well, um we can read the other message here.

A

It tells us that the trade marker copy is not implemented for string. What was minds and does under the hood is trying to apply the copy trade for all the public Fields uh in the structs that are transpired was mine.

A

Then, however, we, you can't really do that with strings right, strings and rusts are not are non-copyable, they are turnable and since objects that are shared between was assembly and JavaScript, they live uh in the webassembly, runtime JavaScript needs to hold a pointer and then there's Auto Magic, like those people need to ask for the properties supported by the object. There's a lot of back and forth and once mindset cannot create a logic for us in this case, so we can do that manually.

A

First of all, we need to drop the public field and we can Implement uh what's called a getter right. We have data deep property. Now, let's expose an ID method, we just scroll on the string and we notice that there's the getter property in the once binds and macro, and similarly we can do the same for the setter. This is a bit um it's a little alarm code to write right. So there's this gather with clone um attribute that does the same.

A

For us and we got uh types valid, um a type output that still has that free method from before that leaks out of the internal details. But, okay, it's usable. Let's move on lifetime! Also uh graphs data structures will likely have lifetime definitions right. Well, you can't really share them to JavaScript directly.

A

You will need to hide them somehow or transform them somehow. So what we see here Russ tells us well, you know, you're, just returning a string, a reference to a string. uh It's a top level function, so you need to add a left time parameter: okay, rust! Let's do that, but let's put static, but if I do that, then there was binding check will kick in and it will tell us that it's currently not safe, um not sound, sorry to use the lifetimes in oras wasm.

A

In fact, there is the issue for that. Okay, then, let's create abstract instead and we put the lifetime definition on the structure rather than on a function, but again a similar type of error.

A

Let's hide the lifetime description uh in a wrapper rubber struct, uh even though the lifetime definition is static right, we got this error. The trade bound into wasm API is not satisfied. What is this? That's not implemented for ref T static and yeah yeah. Well, first of all, it's pronounced wasm ebi, not Wasabi, like I, did the first time. So let's look into that. This is from the ones binding uh source code. So basically there's this into was my bi that um implements what's described.

A

It has this nice ABI type and it's a trait or anything that can be directly serialized pass through webassembly via the foreign function interface uh using the external C uh signature. Basically, and once mindset uses this to convert arguments and then even return types. In that case, the return was maybe I. Trade is used and we've seen that these scenaries from the wasmoscope trade and it's this is pretty cool like the original Creator from West binder.

A

Had this idea of a descriptor that basically creates a program to describe the type definitions of rust structures so that they could be used by JavaScript and then typescript and all the logic of that program is actually compile time. Only so then it's uh stripped out to the webassembly artifact and there's a link to that I'm. Going to share this slides with you, so if you want to follow along all right, so let's move on to some more complex data structures. Vectors everybody needs vectors right. You can't always have a known size arrays.

A

Well. What we have here is a structure of extract forearms. It holds an ID with a vector of full and full is just a struct that holds a scalar value bar with an u32.

A

We notice that both structs uh have the was binding tag right, so the macro is kicking in, but we have this uh four JS subject is not satisfied and the truth. This object is not implemented for full. So what this tells us really is that we can't have a vector we can serialize a vector of a generic type and a similar case instead. Is that um a simpler case? Sorry, it's just using a vector of scalars, in which case we get a serialization. uh It works it compiles.

A

You can use it on typescript, uh it's not really a standard Vector for for JavaScript land. It's a IU into 32 array, which is very similar to the shared buffers you will use with web workers.

A

So it's basically a byte array and the idiomatic Tasker for that will be just ID of number and then square brackets for indicating an array and again there's an open issue has been open since 2018. uh So it's pretty a pretty old problem so moving on, we want to create a parser, and this way it's just defining appsource industry. Maybe you want to have a set of um accepted values, write a closed set of accepted values, for instance uh I'm, defining her provider, a database provider.

A

It might be postgres, my SQL sqlite, and this translates one to one with a typescript. Just by applying the was binding macro fair enough. uh However, the idiomatic Tasker definition will just be using um these Junctions of literals during literals or again just a close set of strings, but it's usable. We can do that. uh It's not a limitation right. Let's move on Russ has this um fantastic feature of apps, abstract data types or algebraic data types, sorry or um enums right, so we have a URL uh Constructor static and amp.

A

They both hold the string. This defines a URL value that you can either read from your environment variables or from uh just a string static definition.

A

Ideally, we would like to map it to discriminated unions in typescript, so it's um we have a tag that just tells us the name of the Constructor basically and then a value that holds the actual actual value that we want to uh represent, and this is a pretty handy representation, because we can then utter match on JavaScript land uh depending on the tag property so depending on the the type of um URL that we want to represent. In this case, however, this is not supported. We see this Arrow here.

A

Only C style enums, which are the ones we saw before, are allowed with, was binder. So basically, over the foreign function interface, we can only serialize enums if they are compatible with uh integers, just like they are in C, and there are a few um discussions going over in the issue a lot of the ball. There was even a PR that was open a few years back. Unfortunately, the original author couldn't proceed.

A

um If you really want to help in the community, jump in on these issues would be great. So can we do better right? We see the web. Verizon is pretty useful tool, I love it, but when it comes to, for instance, type safety or expressiveness sharing expressful data structure, data structures from routes to JavaScript it has some limitations and, like the Roman said, all the rules lead to further. Third is the the factor tool for serializing things right?

A

So there's um this nice little Library, which is officially supported by the rust, wasn't project which is called uh resta, was bindzen, which is a need, a native integration of resident wasm. They claim it's faster than the Json representation. Like the decision serialization, uh it only requires a few macro attributes which are standard for Stardust, so just serialize the serialize on all the data types that you need to return from the rustland to JavaScript land.

A

And, of course, if you have dependencies or dependent types, you need to apply the seam definition on top of them. Also- and the cool thing is the EDT announced that we have just seen before we couldn't transpile via was mines and are supported, are supported and we can even customize them as we want to get idiomatic taskscript as an output.

A

We just need to use the derived feature from a server. However, we cannot return directly the type definitions um from webassembly to types to typescript. What happens is while we can share the data like we can return data and that's not a problem. We can. We need to serialize that your string first. Why is that? Because uh the return was maybe I. Trade uh automatic implementation doesn't kick in with complex data structures, so we're still uh back where we were.

A

What, if like this, is basically typescript. That really wants to use webassembly right, but can't do that right now. I can't do that man what if there was a magic tool that allowed us to get webassembly with types right and that one like little backstory when I applied for this talk I had no clue that this uh tool existed. So this talk was mainly about limitations. Now, I can finally provide you with a solution.

A

uh This tool is called a tsifier as a very recent Library, like only 13 stars on GitHub. Please add some more: it's a automatic typescript definition generator for rust and webassembly. It supports all the nice features that we saw we struggled with before so it supports ADT, announced uh box trucks, functional Library, so you can share hash maps. You can share vectors, vectors or vectors. You can just go play tricky with that. It supports, are just types it builds on.

A

Top of third was binding, so the same Library we've seen before it uses a lot of macros unsafe code magic. It needs to even parse the macro definitions via the darling Library, and it implements that from was maybe I traded. We saw before it was everyone for all the standard, Library data types and here's an example of that.

A

Like first of all, we just need uh three Imports, basically, the standard, the serializing serialized from cerda, the tsify top level uh module, and then there was binding um Prelude, which is a like the standard library for was Minden.

A

We see that tsfi accepts uh some feature Flags to get into more later uh into that later. um Basically, they will allow you to customize the way you serialize your your data and here's our little example. We want to create a discriminated Union of a URL in this case. The same example as before we start with this standard derivation macro, so serialize deserialize, those are from sarda and then tsfi we apply. The tsfi macro we see we have into was maybei from was membi.

A

um That's just a little trick to implement those trades we've seen before under the hood, and this is just a customization, we can apply via sarde. So this is a feature native of sarda uh to get those um discrimination data types output back, so we got those underscore tag and value for um static and nav URLs, and this is just the whole code.

A

So, finally, we have idiomatic task definitions from our rust, structs and enums, and that's great so moving on. We can just show you a little bit of differences between the a little bit of um things you need to be aware of. If you need to compile code, both for rust and webassembly, and then we can move on to the demo so by default. You know if you need to compile a library in Rust, the default uh type create is um lip or air. Lip webassembly is a bit special in that right.

A

It requires a system Library. So the official suggestion by the rust wasm team is to just support the CD lib Target linkage Target. You can actually compile your rascode targeting both uh CD labor early, which is what we're going to do.

A

um This is an example, schema to parse I'm, going to spell it out just for the people in the back. That might not see the screen, so we have an example of the Prisma schema language, I'm, not sure how many are familiar with Prisma, it's mostly uh a product using the typescript land, but it's I, guess half of that code is written in Rust, so we're pretty uh involved in that and it allows you to Define uh uh database collections.

A

Then you can query with our tool, so we Define a database in this case provider is postgres. We could use MySQL, you could use a SQL Server, we Define a URL. We want to read that from the database URL and then we can Define another Shadow database URL, which basically, we use for uh schema migrations and we Define it as a static string right. So this will be the type definition that we expect as an output or typescript.

A

So we see disc, limited unions for the provider, which is idiomatic. We see the URL again spelled out as a abstract algebraic data type. I always mistake that we see um an object for the data source, DB top level object, and then this there's this schema EST, which just represents the collection of all the possible data sources you might have in a schema, and how does this translate into webassembly? How can we return some complex data structure from rust and then use it later in JavaScript? So what we have here?

A

We just have the top level definitions we saw before third and whilst binding. We don't see tsfi here, because that's hidden in another um crate that schema parser create this will be the definition of the function defined in the schema partial, create. We will. You will see that in the repository uh in that crate, we only toggle webassembly, so all those webassembly macros, depending on a feature flag, so you don't need to um like have longer compile times in your main code.

A

If you don't need to use webassembly as a Target, um all the time like you can just opt in later here we see uh this is the function that we exposed from rust to JavaScript. Parts schema wasn't just accepts our input string. We see it's able to return our result, so this translates uh into just a value on JavaScript land or an error like an expected error that you need to try cats physically, um we see that we have a complex return, return value from that parse schema.

A

It returns that schema AST, schema SD has the tsc5 macro. So it's a complex data structure. It's the equivalent of the typescript definition we've seen before written in Rust, uh and it has so it has vectors under the hood. It has enorms Etc. uh The only thing here we see is that we need to manually convert the error type that are that I'm getting from from a string to a JS error. This is a um I can do that via third Json, and it's only use four errors. Anyways.

A

uh It will be the definition so demo time. You will see that uh the repository it's uh the top listed in my uh GitHub account so github.com.

A

Hopefully, you can find that in the schedule link from the URLs, because it's pretty hard to spell and Euros Dash 2022 is a repository name, so I need to yeah.

A

So the first thing how I will show you is how we pass the schema. The schema is this one by the way, so yeah is this one? So we see The Source provider, your URL and shield database URL so the same as before, and we try to parse that from rust side. So this is just a rust, uh CLI application.

A

Okay, we passed that successfully, and this is the just the debug print of the data structures we had used in Rust. So we see that top level schema SD, there's an array of resources, the nums used as adts.

A

We see that we have an option type because the shell database URL is optional, so that is wrapped in a sum: Constructor. Okay, uh we might validate that.

A

Because I also inserted some validation rules, for instance,.

A

ah Yeah sorry validate, for instance, I wrote the code such that it panics uh just a plan. This means that we don't. We cannot support environment variables right now. This is an expected panic. Applications can have it right. We see a message explicitly telling us. What's the problem, it's all right. We can fix that. So we just take this.

A

Take out this e m definition right. We save it now we have just static URLs, so we no longer expect a panic, so the schema is parsed correctly, but we have a validation error. We see that uh the URLs for the postgres provider can only start with via the postgres protocol right. So we need to change that.

A

Just let's copy this paste it in and let's try again and everything parses and validates successfully. Now this is easy done in Rust we didn't share. uh We didn't serialize any of the structure.

A

We are, however, using an artifact that was, we wanted to um use on wasma assembly as well, so we have. We have added to compile for both platforms. Now, let's use that from node.js land. First, let's try. We are just a schema, parsing, okay and we see that's part successfully. Let me yep, so we see a similar output. We have a attack value here. We see a data source is a DB type. It has a possible provider.

A

The shadow database is now, unfortunately in JavaScript we have a nulls, so um we can always improve that um now, let's see what happens when we have errors and panics, because this gets a bit tricky. So, first of all, let's validate that uh we're not using the Sim schema now we're using predefined schemas.

A

Here we have an error. It tells us that the provider uh cockroaches B is not supported. Okay, fine! We we see an error. We see explicit messages how about panics? What do we expect will happen with panics.

A

Okay, this is a bit hard to parse. We see a few hexadecimal um values, we see a runtime error are reachable, but that's not the Panic methods. I. We saw before right with webassembly, we lose all informations about uh Panic messages and that's just only one of the limitations. Of course you already know that we lose all input output, information. If you have any print line, any warning you lose that because webassembly doesn't support input output uh once it does uh it.

A

You also cannot um cats are Panic, you know in Russia you call the technically unwind unwind panics. You can no longer do that in in webassembly and even in the rust wasn't demos they show online. They tell you well, technically, you will. You could be able to show the message, the original message for your panics by writing these hundred lines of code right, but you cannot really capture that you can only print that to this uh to the standard console, dot, error method provided by JavaScript.

A

So you will need to call a JavaScript method um and you you will lose access to the actual error. You can only print that. uh uh So that's a limitation. All right, um moving on so to wrap this up. Webassemble is very useful. It's here to say, like I, think the first major platform that used webassembly was figma back in 2016 17 at least, um and they have just IP. They have just been acquired for a lot of money, so I think they were on.

A

The right way uh was minding it's a great tool, but we've seen it has some limitations. uh It limits your expressiveness for the structures. Unfortunately, some problems have been open, um have been known for a while and haven't been solved yet so, if you're, into open source contribution, please give a hand, um sir, that was binding, overcomes most of the limitations we've seen for was binding, but it's still not enough for typescript users and I would assume that in most complex DS products uh I will assume.

A

Most of them are written in typescript, uh because once you try types, you never really go back. So typescript is pretty important. It's also 10 years old. Now it's stable and tsfi is a promising new tool that basically provides the best developer experience. I had so far uh for this type of uh interchanging. Between uh of the structures between webassembly raster mode assembly and typescript, um however, it might be hard to introduce that in your company. Why is that?

A

Well, first of all, it relies on a lot of macros or there's a lot of magic under the hood. um Your your other colleagues might not be comfortable with having such a magic tool as a dependency. You might increase your compilation times.

A

uh It's also not that well tested not well um documented yet, but we have seen it's a really recent tool, so hopefully it will become more mature. I would also imagine that at some point uh they will merge some of the features that tsfi provides into the was mind Zone repository directory I would love that um so just to wrap this up, webassembly is really underrated.

A

If you haven't had a chance yet try it all right. That's all from me thanks, uh you see. Thank you. You see the example code and a lot more demos. Actually uh in the GitHub link, the Commando, slash, Euro 2022.